2022-03-14
day0314
Person类
package day0314;
public class Person {
public String name;
public int age;
public String sex;
public void eat() {
System.out.println("人吃东西");
}
public Person() {
System.out.println("父类Person的无参构造");
}
public Person(int age) {
this.age = age + 1; //this.指向成员变量,区分于方法内的局部变量
System.out.println("父类的单参构造" + age);
}
public Object sleep() {
System.out.println("人在睡觉");
return 0;
}
public static void a() {
}
}
Teacher类
package day0314;
public class Teacher extends Person {
public int teacherYear;
public int age; //重写一个与父类重名的成员变量,对父类的成员变量进行隐式
public void teach(String lesson) {
System.out.println("教师讲" + lesson);
}
public static void main(String[] args) {
// Teacher teacher = new Teacher(); //创建Teacher类的对象teacher
// teacher.teach("数学");
// teacher.teacherYear = 3;
Teacher teacher2 = new Teacher(19);
System.out.println(teacher2.sleep());
}
public Teacher() { //隐式调用父类的无参构造 Person()
super(); //显示调用父类的无参构造
System.out.println("子类Person的无参构造");
// super(); //super() 只能在首行
}
public Teacher(int age) { //隐式调用父类的无参构造 Person()
super(age); //显示调用父类的单参构造，显示调用生效时，不再进行隐式调用
// super.age = age + 1;
System.out.println("教师的年龄是" + age);
// System.out.println("教师的年龄是" + this.age);
// System.out.println("教师的年龄是" + super.age);
}
// @Override //方法重写(覆盖)的校验注解
// public void sleep() {
// System.out.println("教师在睡觉");
// }
public String sleep() { //报错
return "123";
}
// public void a() { //报错
//
// }
}
Dog类
package day0314;
public class Dog {
protected String name; //protected受保护的，可以被子类所继承
public int age;
private String color; //private属性不能被继承
public void eat() {
System.out.println("小狗吃东西");
}
}
PetDog类
package day0314;
public class PetDog extends Dog { //继承父类，Dog
public String nickName; //昵称
public void wash() {
System.out.println("给宠物狗洗澡");
}
public void lookAfter() {
System.out.println("照料宠物狗");
}
public static void main(String[] args) {
Dog dog = new Dog(); //创建一个Dog类的对象dog
// dog.wash(); //父类不可调用子类的独有方法
// dog.nickname = "hei"; //父类不可调用子类的独有属性
PetDog petDog = new PetDog(); //创建一个PetDog类的对象petDog
petDog.age = 10; //继承自父类的属性
petDog.name = "wangwang"; //继承自父类的属性
// petDog.color; //报错
petDog.eat(); //继承了父类的eat()方法
petDog.wash(); //子类对象调用子类独有的方法
petDog.nickName = "wenxi";
}
}
Car类
package day0314;
public class Car {
public int speed;
public void speedUp() {
speed += 10;
}
}
Bus类
package day0314;
public class Bus extends Car {
public int speed; //子类成员变量
public void speedUp() {
speed += 5;
super.speedUp(); //调用父类的同名方法
System.out.println(speed); //不含super，指向当前类的成员变量
System.out.println(super.speed); //super.属性 指向父类的成员变量
}
public void sell() {
System.out.println("公共汽车售票");
}
public static void main(String[] args) {
Bus bus = new Bus();
bus.speedUp();
}
}
homework
Animal类
package day031401;
public class Animal {
String name;
int age;
public String eat(String thing) {
System.out.println("动物吃" + thing);
return thing;
}
public void bark() {
System.out.println("动物会叫");
}
}
Cat类
package day031401;
public class Cat extends Animal {
@Override
public String eat(String thing) {
// super.eat("东西");
System.out.println("小猫吃" + thing);
return thing;
}
@Override
public void bark() {
System.out.println("小猫喵喵叫");
}
}
Dog类
package day031401;
public class Dog extends Animal {
@Override
public String eat(String thing) {
System.out.println("小狗吃" + thing);
return thing;
}
@Override
public void bark() {
System.out.println("小狗汪汪叫");
}
}
Test类
package day031401;
public class Test {
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "大毛";
cat.age = 2;
System.out.println("小猫的名字叫" + cat.name + "，今年" + cat.age + "岁了");
System.out.println(cat.eat("鱼"));
cat.bark();
Dog dog = new Dog();
dog.name = "旺财";
dog.age = 3;
System.out.println("狗的名字叫" + dog.name + "，今年" + dog.age + "岁了");
System.out.println(dog.eat("骨头"));
dog.bark();
}
}
2022-03-15
day0315
Animal类
package day0315;
public class Animal {
public int age = 5;
public void eat() {
System.out.println("动物吃东西");
}
@Override
public boolean equals(java.lang.Object obj) {
// TODO Auto-generated method stub
return super.equals(obj);
}
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return false;
}
}
Cat类
package day0315;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("小猫吃鱼");
}
}
Dog类
package day0315;
import java.lang.Object;
public class Dog extends Animal {
public int age = 10; //子类与父类同名的属性
public int weight = 6; //子类独有的属性
@Override
public void eat() {
System.out.println("狗吃肉");
}
public void playBoard() {
System.out.println("小狗玩球");
}
public Dog() {
}
public Dog(int age, int weight) {
this.age = age;
this.weight = weight;
}
@Override
public boolean equals(Object obj) {
return obj instanceof Dog && this.age == ((Dog)obj).age
&& this.weight == ((Dog)obj).weight;
}
// @Override
// public String toString() {
// return "它的年龄：" + this.age + "，它的重量" + this.weight;
// }
@Override
public String toString() {
return "Dog [age=" + age + ", weight=" + weight + ", toString()=" + super.toString() + "]";
}
}
Pig类
package day0315;
public class Pig extends Animal {
@Override
public void eat() {
System.out.println("小猪吃饲料");
}
}
Test类
package day0315;
public class Test {
public static void main(String[] args) {
Dog dog = new Dog(); //创建一个Dog类对象dog
System.out.println("小狗的年龄和体重分别是" + dog.age + "，" + dog.weight);
dog.eat();
dog.playBoard();
//创建一个Dog类对象，赋值给左边Animal引用
//父类名 变量名 = new 子类();
Animal animal = new Dog(); //编译看到是左边，Animal，所以没有weight会报错
System.out.println("小狗的年龄和体重分别是" + animal.age + "，");
animal.eat();
// animal.playBoard(); //报错
animal = new Cat(); //创建Cat类的对象，赋值给父类的引用
trullyEat(animal);
animal = new Pig();
trullyEat(animal);
}
public static void trullyEat(Animal animal) {
//传参的过程 Animal animal = new Cat或者Pig();
animal.eat();
}
}
Person类
package day0315;
public class Person {
public void work() {
System.out.println("人要工作");
}
}
Student类
package day0315;
public class Student extends Person{
public void tuanke() {
System.out.println("学生上团课");
}
@Override
public void work() {
System.out.println("学生的工作是学习");
}
}
Teacher类
package day0315;
public class Teacher extends Person {
@Override
public void work() {
System.out.println("教师的工作是上课");
}
}
PersonDemo类
package day0315;
public class PersonDemo {
public static void main(String[] args) {
//向上转型 从子到父 父类引用指向子类对象
Person person = new Student();
person.work();
// person.tuanke(); //报错
// Student student = new Student();
// student.tuanke();
//向下转型 从父到子 子类的引用指向父类的变量
// Student student = (Student) person; //不用新建对象的方法，使用向下转型
// student.tuanke();
// Teacher teacher = (Teacher) person; //编译不报错，执行报错。父类引用的对象与向下转型的子类是同一个。 day0315.Student cannot be cast to day0315.Teacher
if (person instanceof Teacher) { //instanceof 检查对象是否属于某一个类
Teacher teacher = (Teacher) person; //属于同一类，进行强制转换
} else {
System.out.println("person指向的子类不属于Teacher类");
}
}
}
ObjectDemo类
package day0315;
public class ObjectDemo {
public static void main(String[] args) {
//1.equals方法
ObjectDemo a = new ObjectDemo();
ObjectDemo b = new ObjectDemo();
System.out.println(a == b); //比较地址
System.out.println(a.equals(b));
Dog c = new Dog(1, 2);
Dog d = new Dog(1, 2);
System.out.println(c.age);
System.out.println(c.weight);
System.out.println(d.age);
System.out.println(d.weight);
System.out.println(c.equals(d));
//2.toString()方法
// a.toString();
System.out.println(a);
System.out.println(c);
//3.hashCode()方法
//4.其他方法
}
}
day031501
package day031501;
public class BBQChicken {
public int price; //价格
public int weight; //重量
public BBQChicken() {
}
public BBQChicken(int price, int weight) {
this.price = price;
this.weight = weight;
System.out.println("你调用了BBQChicken类的两参构造方法");
}
@Override
public boolean equals(Object obj) {
return obj instanceof BBQChicken && this.price == ((BBQChicken)obj).price
&& this.weight == ((BBQChicken)obj).weight;
}
}
package day031501;
public class Test {
public static void main(String[] args) {
BBQChicken bbqChicken = new BBQChicken(); //先用无参构造，后赋值
bbqChicken.price = 15;
bbqChicken.weight = 10;
BBQChicken bbqChicken2 = new BBQChicken(15, 10); //直接用两参构造完成赋值
System.out.println(bbqChicken2.equals(bbqChicken)); //false，不重写时，调用的是Object类的equals方法
}
}
