多态,object,toString,equals,abstract,javabean的快速生成

第一章 多态

1 多态

• 一种事物的多种形态|表现形式
  行为多态

2 多态前提

• 继承 | 实现

3 多态的最终表现形式

• 父类引用指向子类对象

4 多态的调用

• 正常调用 : p或者s调用的成员 : 1)自己类中存在的成员 2)从父类中继承的成员

• 多态的调用 : 父类引用调用
  成员变量 :
  编译运行看父类|左边|类型

  ​ 成员方法 :
  ​ 编译看父类|左边|类型,运行找子类|右边|对象

• 注意 : 如果没有配合方法的重写,多态就没有意义

5 例子

public class Class001_Poly {
    public static void main(String[] args) {
        //对应类型数据赋值给对应类型的变量
        Person p = new Person();
        Student s = new Student();
        //正常调用 : p或者s调用的成员 : 1)自己类中存在的成员  2)从父类中继承的成员


        //多态
        Person  ps=  new Teacher();
        //多态的调用
        System.out.println(ps.str);

        ps.test();

    }
}

class Person{
    String str = "父类";

    public void test(){
        System.out.println("Person----> test");
    }
}

class Student extends Person{
    String str = "子类";

    public void test(){
        System.out.println("Student----> test");
    }
}

class Teacher extends Person{
    String str = "子类2";

    public void test(){
        System.out.println("Teacher----> test");
    }
}


class Animal{}

6 练习

做题四大原则:

• 继承链:自己没有找父类

​ A

​ |

​ B

​ / \

​ C D

• 编译看类型、确定方法，运行找对象

• 就近最优原则

• 父类引用对子类新增方法不可见

public class Class002_Practice {
	public static void main(String[] args) {
		A a1=new A(); //A and D   A and A
		//多态
		A a2=new B(); //A and D   B and A
		B b =new B(); //B and B   B and A   A and D
		C c=new C();
		D d =new D();
		System.out.println(a1.show(b)); //  A and A B往上找,找A
		System.out.println(a1.show(c)); //  A and A C往上找,找A
		System.out.println(a1.show(d)); //  A and D
		System.out.println(a2.show(b)); //  B and A
		System.out.println(a2.show(c)); //  B and A
		System.out.println(a2.show(d)); //  A and D
		System.out.println(b.show(b));  //  B and B
		System.out.println(b.show(c));  //  B and B
		System.out.println(b.show(d));  //  A and D
	}

}

class A{
	public String show(D obj){
		return ("A and D");
	}
	public String show(A obj){
		return ("A and A");
	}
}

class B extends A{
	//新增方法
	public String show(B obj){
		return ("B and B");
	}
	public String show(A obj){
		return ("B and A");
	}
}

class C extends B{
}

class D extends B{
}

7 数据类型转换

7.1 基本数据类型转换

​ 自动类型提升 : 小 —> 大
​ 强制类型转换 : 大 —> 小
​ 小范围类型 变量 = (小范围类型)大范围类型数据;

7.2 引用 : 转型

• 小: 子类 大 : 父类

• 向上转型 : 子类 --> 父类

• 向下转型 : 父类 --> 子类
  子类类型 变量 = (子类类型)父类引用;
  需求 : 当多态调用不能调用子类独有内容时候,可以向下转型,然后调用子类独有内容

  ​ java.lang.ClassCastException类型转换异常
  ​ 在向下转型的时候,如果抓成其他的子类类型,就会遇到这个异常

• instanceof 运算符
  引用 instanceof 类型 : 判断前面的引用是否指向后面类型的对象或者后面类型的子类对象,如果是返回true,不是返回fales

7.3 例子

public class Class001_Cast {
    public static void main(String[] args) {
        int i = 1;
        //自动类型提升
        long l = i;
        //强制类型转换
        int i2 = (int)l;


        Zi zi = new Zi();
        //向上转型
        Fu fu = zi;
        //多态
        Fu f = new Zi(); //f对子类新增内容不可见



        //向下转型
        //Zi zi2 = (Zi)f;  //Zi zi2 = new Zi();  --> 可以调用子类独有内容
        //转型转错了,转成了其他的子类类型---> java.lang.ClassCastException类型转换异常

        if(f instanceof Brother){
            Brother zi2 = (Brother)f;  //Brother zi2 = new Zi();  --> 可以调用子类独有内容
            zi2.test();
        }else if(f instanceof Zi){
            Zi zi2 = (Zi)f;
            zi2.test();
        }

        System.out.println(f instanceof Fu);  //T
        System.out.println(f instanceof Zi);  //T
        System.out.println(f instanceof Brother);  //F
    }
}
class Fu{}

class Zi extends Fu{
    String str="Zi";
    void test(){
        System.out.println("子类Zi方法test");
    }
}

class Brother extends Fu{
    String str="Brother";
    void test(){
        System.out.println("子类Brother方法test");
    }
}

第二章 object 与 toString

1 Object

• 老祖宗类
• 是java中所有类的父类
• 如果一个类没有显示的继承父类,默认继承自Object类

2 toString

2.1 理解

• 返回对象的字符串表现形式

​ public String toString() {
​ return getClass().getName() + “@” + Integer.toHexString(hashCode());
​ }

• 当输出一个对象 的引用的时候,输出的是对象的引用调用toString方法的返回值==>默认调用toString
• 为什么要在子类中重写toString方法 :
  因为输出对应的引用时候不想是打印对象的地址值,想要输出对象的所有属性值,对从Object中继承的toString需要,toString实现不满意,在子类中重写toString
• 注意 : 当定义javabean类型,规范都需要重写toString

2.2 实例

public class Class001_Object{
    public static void main(String[] args) {
        Student s = new Student(1001,"张三丰",100);
        System.out.println(s);
        System.out.println(s.toString());
    }
}

class  Student{
    int no;
    String name;
    int age;

    public Student(){}
    public Student(int no,String name,int age){
        this.no = no;
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return no+"-->"+name+"-->"+age;
    }

}

第三章 equals

1 equals 与 == 的区别

• == : 比较两个数据是否相等
  基本 : 数据值
  引用 : 对象地址值
• equals : 比较两个对象数据是否相等
  Object类中的equals方法 : 默认比较对象的地址值
  public boolean equals(Object obj) {
  return (this == obj);
  }

2 重写equals方法

• 为什么要子类中重写equals方法 :
  使用Object类的equals方法,默认比较对象地址,业务需求想要比较根据对象的属性值比较是否相等,可以在子类中根据需要重写equals,实现比较对象所有属性而非地址值
• 比较字符串类型的数据 : 使用String重写的equals比较字符串对象的内容而非地址

3 实例

public class Class001_Object{
    public static void main(String[] args) {
        Student s1 = new Student(1001,"张三丰",100);
        Student s2 = new Student(1001,"张三丰",10);
        System.out.println(s1);
        System.out.println(s1.toString());

        System.out.println(s1.equals(""));;
    }
}

class  Student{
    int no;
    String name;
    int age;

    public Student(){}
    public Student(int no,String name,int age){
        this.no = no;
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return no+"-->"+name+"-->"+age;
    }

    //比较字符串类型的数据 : 使用String重写的equals比较字符串对象的内容而非地址
    public boolean equals(Object obj) { //Object obj = new Student(1001,"张三丰",100);
        //增强程序健壮性判断
        if(this==obj){
            return true;
        }
        //两个对象 : this  obj
        //obj向下转型
        if(obj instanceof Student){
            Student s = (Student)obj;
            //两个对象 : this  s
            return this.no==s.no && this.age==s.age && this.name.equals(s.name);
        }
       return false;
    }
}

第四章 快捷键快速生成javabean

public class Car {
    private String brand;
    private String color;
    private double price;

    //空构造
    //快捷键 :  alt+insert-->enter--> tab-->tab-->enter
    public Car() {
    }
    //快捷键 :  alt+insert-->enter--> shift+方向上下键-->enter
    public Car(String brand, String color, double price) {
        this.brand = brand;
        this.color = color;
        this.price = price;
    }

    //设置器访问器
    //快捷键 :  alt+insert-->shift+方向上下键选中setter and getter --> enter--> shift+方向上下键选中属性 -->enter
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    //快捷键 : alt+insert-->shift+方向上下键选中toString --> enter-->enter
    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                '}';
    }

	//快捷键 : alt+insert-->equals() and hashcode() --> 一直enter
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 &&
                Objects.equals(brand, car.brand) &&
                Objects.equals(color, car.color);
    }

}

第五章 abstract抽象类

1 abstract 抽象的

​ 抽象类 : 被abstract修饰的类
​ 抽象方法 : 被abstract修饰的方法
​ 没有方法体
​ 必须存在与抽象类中

2 需求

定义开发部门不同职位工作内容

​ 开发部门 Develop --> work()
​ java攻城狮 : work–> 后端开发
​ web程序猿 : work–> 前端开发

3 注意

• 抽象类不能实例化
• 抽象方法必须存在与抽象类中
• 抽象类中可以定义可以不定义抽象方法,可以定义任意内容
• 抽象类的使用 :
  1)具体子类对象调用成员
  重写所有的抽象方法 + 按需新增
  2)抽象子类
  按需重写 + 按需新增
• 抽象方法必须被重写的,但是只需要重写一次,按需重写多次
• abstract不能与private,final,static,native一起使用