目录

         多态

static关键字

抽象类

接口

内部类

多态

动态编译：类型--->可扩展性

同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类或者有关系的类）

多态存在的条件

有继承关系

子类重写父类方法

父类引用指向子类的方法

注意：多态是方法的多态，属性没有多态性

static是方法，属于类，不属于实例，故没有多态

final 常量，没有多态

private方法，私有的，没有多态

    public static void main(String[] args) {
         //一个对象的实际类型是确定的
         //new Student()
         //new Person()
         //可以指向的引用类型就不确定了
 ​
         Student s1 = new Student();  //student能调用的方法都是自己的，或者继承父类的
         Person s2  = new Student();  //父类的引用指向子类，但是不能调用子类独有的方法
         Object s3  = new Student();
 ​
         s1.run();  //子类重写了父类的方法，执行子类的方法
         s2.run();
 ​
         
         s1.eat(); //
         ((Student) s2).eat(); //可以强制转换，由父转子，即高转低
 //        s2.eat();  //父类的引用指向子类，执行了子类中有而父类中没有的方法会报错
     }

instanceof 类型转换

    public static void main(String[] args) {
         //Object > String
         //Object > Person >Teacher
         //Object > Person >Student
         //System.out.println(X instanceof Y); //如果X与Y之间存在关系，则编译通过，否则报错
                                               //注意必须是单线上的关系
         Object object = new Student();
 ​
         System.out.println(object instanceof  Student); //ture
         System.out.println(object instanceof  Person);  //ture
         System.out.println(object instanceof  Object);  //ture
         System.out.println(object instanceof  Teacher); //false
         System.out.println(object instanceof  String);  //false
         System.out.println("=======================");
 ​
         Person person = new Student();
         System.out.println(person instanceof  Student); //ture
         System.out.println(person instanceof  Person);  //ture
         System.out.println(person instanceof  Object);  //ture
         System.out.println(person instanceof  Teacher); //false
 //        System.out.println(person instanceof  String);  //编译报错
         System.out.println("=======================");
 ​
         Student student = new Student();
         System.out.println(student instanceof  Student); //ture
         System.out.println(student instanceof  Person);  //ture
         System.out.println(student instanceof  Object);  //ture
 //        System.out.println(student instanceof  Teacher); //编译报错
 //        System.out.println(person instanceof  String);   //编译报错
     }
 ​
 ​
 ================================================================================
     public static void main(String[] args) {
         //类型之间的转换   父    子
         //高 ------------------->  低 （需要强制转换）
         Person obj  = new Student();
         //obj.go();  //当前obj对象为Person类型，可以转为Student类型，然后便可用Student的方法
         Student student = (Student) obj;
         student.go();  //已然转换为student类型，可以使用Student的方法
         ((Student) obj).go(); //也直接一步转换输出
 ​
         //低 ------------------->  高 （自动进行）
         //子类转父类，可能丢失自己的本来一些方法
         Student student1 = new Student();
         student.go();
         Person person = student1;
     }

父类引用指向子类的对象

把子类转换为父类，向上转型：自动进行

把父类转换为子类，向下转型：强制转换

方便方法的使用，减少重复的代码

static关键字

static的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法！

注意，静态只能被静态访问

static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

只会在类加载的时候执行一次。因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

     //匿名代码块，执行比构造方法先，比静态代码块慢
     {
         System.out.println("匿名代码块");
     }
 ​
     //静态代码块：与类同时加载，因此在三个里面最先执行，且只会执行一次
     static{
         System.out.println("静态代码块");
     }
 ​
     //构造方法：方法里面最先执行的，但是比静态代码块和匿名代码块慢执行
     public Person() {
         System.out.println("构造方法");
     }
 ​

静态导入包

抽象类

抽象类也是一种类，也是由extends单继承

抽象类只有抽象方法的方法名字，没有方法的实现

不能用new这个抽象类，只能靠子类去实现它---->约束作用

抽象类中可以写普通方法

抽象方法只能在抽象类中

总结就是抽象的抽象---->约束作用

问题：

存在构造器吗？ 答：抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法

存在的意义？ 答：提高开发效率

接口

区分

普通类：只有具体的实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范！自己无法写方法---->专业的规范（约束和实现分离）

interface 定义的关键字

定义

接口中的所有方法定义都是抽象的 public abstract

接口中的所有常量定义都是抽象的 public static final

类可以实现多个接口，implements关键字--->实现接口的方法

实现接口的类，就需要重写接口中的方法

可以利用接口实现多继承

接口不能被实例化，因为接口中没有构造方法

内部类

成员内部类

可以通过外部类来实例化内部类

内部类可以获得外部类的私有属性

 public class outer {
     private int id=10;
     public class Inner{
         public void  in (){
             System.out.println(id);
         }
     }
 }
 ​
 ​
 public class Application {
     public static void main(String[] args) {
         outer outer = new outer();
         //通过外部类来实例化内部类
         outer.Inner inner = outer.new Inner();
         inner.in();
     }
 }

静态内部类

一个java文件中可以有多个class文件，但是只要有一个public class文件

局部内部类

 public class Application {
     //局部内部类
     public void method(){
         class Inner{
 ​
         }
     }
 }

匿名内部类