Java 8 多态

十五、Object类

Object 类是所有 Java 类的根基类

如果在类的声明中未使用 extends 关键字指明其基类，则默认基类为 Object 类

在java中所有的类都会继承自Object类,因为不是直接继承,就是间接继承

1、toString: 当打印对象的引用时,默认调用toString()方法

toString : 返回对象的字符串表现形式，来自于Object类中toString方法的实现 :

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

*当在java中输出一个对象的引用时候,默认输出的是对象调用了toString方法的返回值（地址值）

*结合业务,希望输出一个对象的引用 时候,想要输出的是这个对象的所有属性值,而非地址值

*以后在定义实体类的时候,都应该根据所有的属性重写toString方法

2、实体类的定义规范 | Javabean类的定义规范:

1）.类是公共的 2）.至少提供一个空构造,根据需求提供带参 3）.属性私有化,提供一对公共的访问方式 4）.根据所有属性值重写toString方法

3、equals:比较相等是否相等

默认地址比较(”第一个盒子的比较”) 重写可以是实现比较两对象的内容是否一致

object1.equals(object2)
如 : p1.equals(p2)
• 比较所指对象的内容是否一样,具体看equals的方法重写
object1 == object2
如：p1==p2
• 比较p1和p2的值即内存地址是否相等，即是否是指向同一对象。

注意:自定义类须重写equals()，否则无法实现比较其内容

4、==和equals之间的区别

比较是否相同，返回值都是boolean

区别：

（1）、比较的数据的类型不同

= =基本数据类型的数据值

引用数据类型的对象

equals：比较引用数据类型的对象数据

（2）、比较内容不同

= =基本数据类型的数据值是否相等

引用数据类型的对象的地址值

equals：

来自Object类中的equals默认的是比较对象的地址值

public boolean equals（Object obj）{

return （this==obj）；

}

如果在使用equals方法比较对象时候，不想要比较地址，想要比较内容（属性值）------>在子类中进行重写

5、定义类的定义规范 | Javabean类的定义规范：

one：类是公共的

two： 至少提供一个空构造，根据需求提供带参

three：属性私有化，提供一对公共的访问方式

four：根据所有的属性值重写toString方法与equals方法

十六、多态（polymorphism）

1、多态

多态是一种事物的多种形态|多种表现形式|多种实现方式 ----->一个功能不同实现形式

实现多态的前提：类的继承 | 接口的实现

多态的最终体现：父类的引用指向对象

对应类型引用强调：

能调用的成员包含，子类中定义的成员 + 父类中的继承的成员

如果子类中存在重写方法，调用子类中重写后的方法对父类的方法进行屏蔽

多态的调用：

调用成员变量：编译运行找父类 | 看左边 | 看类型

调用成员方法：编译看父类 | 左边 | 类型，运行找子类 | 右边 | 对象

多态引用对子类新增成员不可见，但是如果子类中存在方法重写，会调用重写后的方法

注意：如果使用多态但是不配合方法的重写，多态就没有意义

2、转型（Cast）

标准赋值 : 对应类型的数据赋值给对应类型的变量 int i = 1; Person p = new Person(); 基本数据类型的类型转换 : 自动类型提升 : 小-->大 long l = i; 强制类型转换 : 大-->小 int i2 = (int)l; 引用数据类型的转型 : 向上转型 : 小-->大 Person p = new Student();-->多态 向下转型 : 大-->小 Student s = (Student)p; java.lang.ClassCastException : 类型转换异常 避免类型转换异常的出现 :instanceof 运算符 语法 : 引用 instanceof 类型 判断前面的引用是否是指向后面类型的对象|子类对象,如果是返回true,不是返回false

3、 instanceof

使用前提:在向下转型的时候,为了避免类型转换异常 ClassCastException 的出现,可以使用instanceof进行判 断。

Animal animal = new Dog();
System.out.println(animal instanceof Animal);
System.out.println(animal instanceof Cat);
System.out.println(animal instanceof Dog);
//先判断后转型
if(animal instanceof Dog){
    Dog dog = (Dog) animal;
}

十七、抽象的（abstract ）

abstract修饰类 : 抽象类
        应用场景 : 1)想要包含定义抽象方法   2)当前类不能实例化
abstract修饰方法 : 抽象方法
        没有方法体
        必须存在于抽象类中

抽象方法指只有功能声明，没有功能主体实现的方法。 具有抽象方法的类一定为抽象类。 那么犬科就可以定义为抽象类，吼叫方法为抽象方法，没有方法体。 通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

1、定义

抽象方法 : 不需要方法体的方法，需要用 abstract 关键字修饰。只能出现在抽象类中。

抽象类 : 被 abstract 修饰的类为抽象类。

public abstract class Canine{
  private String brand;
 
  public Canine(){}
 
  public Canine(String brand){
    this.brand = brand;
 }
  //抽象方法
  public abstract void shout();
 
  //具体方法
  public void sleep(){
    System.out.println("闭着眼睛睡觉!!!");
 }
}

2、抽象类的使用要点

1.抽象类不能实例化
2.抽象类中可以包含属性,功能,静态,非静态的,抽象的,构造器...
3.抽象类的使用 :
    可以根据抽象类类名调用类中的静态内容
    可以根据抽象类的具体子类对象,调用成员
        具体子类 : 重写所有抽象方法 + 按需新增
        抽象子类 : 按需重写 + 按需新增
4.抽象方法一旦被重写一次,后续可以按需重写
5.abstract不能与private,final,static,native不能一起使用的
6.抽象类也是类,可以发生多态

十八、接口

普通类：具体实现 抽象类：具体实现，规范(抽象方法) 接口：规范(抽象方法)

1、接口 :

是一种引用数据类型 ​ 特殊的抽象类 ​ 提高代码的复用性 ​ 类只能单继承,接口可以多实现 ​ 解耦(降低耦合度) ​ 定义开发规范 ​ 一般为抽象功能的集合

2、继承 ：子类 父类

子类一旦继承父类,有权使用父类的成员,继承侧重点关注的是 : 如果从父类中继承的成员满意,马过来直接使用 ​

3、实现 ：实现类 接口

实现类一旦实现接口,具有了接口带来的功能,实现侧重点关注的是 : 实现类一旦实现接口,需要先对抽象方法进行重写,然后才能使用 ​

4、定义 : 通过interface定义接口

[权限修饰符]  interface 接口名  [extends  父接口1，父接口2…] {
        常量定义；
        抽象方法定义；
}

5、语法 :

jdk7及之前 : ​ 公共的静态的常量 : public static final 任意省略 ​ 公共的抽象的方法 : public abstract 任意省略

6、使用 :

1.接口不能实例化（不能new对象） ​ 2.类只能单继承,接口可以多实现 ​ 3.定义一个实现类去实现接口 implements（实现） ​ 4.需要通过具体实现类对象进行调用 ​ 具体实现类 : 重写所有的抽象方法 + 按需新增 ​ 抽象实现类 : 按需重写抽象方法 + 按需新增 ​ 需要具体子类继承,重写所有没有重写的抽象,通过具体子类对象进行调用 ​ 5.如果同时存在继承与实现,需要先继承后实现 ​ 6.类与类之间,只能继承,单继承 ​ 类与接口之间,只能实现,类实现接口,可以多实现 ​ 接口与接口之间,只能继承,可以多继承

7、接口的本质

接口就是 规范 ，定义的是一组规则，接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守

8、接口使用要点

子类通过 implements 来实现接口中的规范 接口不能创建实例，但是可用于声明引用变量类型。 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是 public 的。 接口中只能包含 静态常量、抽象方法 ，不能有普通属性、构造方法、普通方法、静态块。

public class Class001_Interface {
    public static void main(String[] args) {
        System.out.println(Smoke.PI);
        //Smoke.PI = 1.1;
​
        //具体实现类对象
        Impl1 impl1 = new Impl1();
        impl1.smoking();
        impl1.test();
    }
}
​
//接口
interface Smoke{
    //公共的静态的常量
    double PI = 3.14;
​
    //公共的抽象的方法
    void smoking();
    void test();
}
​
​
//具体实现类
class Impl1 extends Object implements Smoke,D{
​
    @Override
    public void smoking() {
        System.out.println("边吸烟变吐烟圈...");
    }
​
    @Override
    public void test() {
        System.out.println("测试...");
    }
​
    @Override
    public void a() {
​
    }
​
    @Override
    public void b() {
​
    }
​
    @Override
    public void c() {
​
    }
}
​
interface A{
    void a();
}
interface B{
    void b();
}
interface C{
    void c();
}
​
interface D extends A,B,C{}