【阶段一】java之面向对象下

多态

1、认识多态
多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。

多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活的编程，提高系统的可扩展性。

允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

相同类域的不同对象,调用相同的方法,执行结果是不同的

1.一个对象的实际类型是确定的

例如: new Student(); new Person();等

2.可以指向对象的引用的类型有很多

一个对象的实现类型虽然是确定的，但是这个对象所属的类型可能有很多种。

例如：Student继承了Person类

Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

因为Person和Object都是Student的父类型

一个父类引用可以指向它的任何一个子类对象
例如：

Object o = new AnyClass();
Person p = null;
p = new Student();
p = new Teacher();
p = new Person();

多态中的方法调用

public class Person{
    public void run(){}
}

public class Student extends Person{

}

调用到的run方法,是Student从Person继承过来的run方法

Person p = new Student();
p.run();

例如：

public class Person{
    public void run(){}
}

public class Student extends Person{
    public void run(){
    //重写run方法
    }
}

//调用到的run方法,是Student中重写的run方法
public static void main(String[] args) {
    Person p = new Student();
    p.run();
}

注：子类继承父类,调用a方法，如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法, 如果重写了,那么调用的就是重写之后的方法。

子类中独有方法的调用

public class Person{
    public void run(){}
}

public class Student extends Person{
    public void test(){
    }
}

main:
Person p = new Student();
//调用到继承的run方法
p.run();

//编译报错,因为编译器检查变量p的类型是Person,但是在Person类中并没有发现test方法,所以编译报错.
p.test();

注：一个变量x，调用一个方法test，编译器是否能让其编译通过，主要是看声明变量x的类型中有没有定义 test方法，如果有则编译通过，如果没有则编译报错。而不是看x所指向的对象中有没有test方法。

原理：编译看左边，运行不一定看右边。

编译看左边的意思：java 编译器在编译的时候会检测引用类型中含有指定的成员，如果没有就会报错。 子类的成员是特	
有的，父类的没有的，所以他是找不到的。
所以看左边，Person 中没有test()方法，于是编译报错

子类引用和父类引用指向对象的区别

Student s = new Student();
Person p = new Student();

变量s能调用的方法是Student中有的方法(包括继承过来的)，变量p能调用的方法是Person中有的方法(包括继承过来的)。

但是变量p是父类型的，p不仅可以指向Student对象，还可以指向Teacher类型对象等，但是变量s只能指 Studnet类型对象，及Student子类型对象。变量p能指向对象的范围是比变量s大的。

Object类型的变量o，能指向所有对象，它的范围最大，但是使用变量o能调用到的方法也是最少的，只能调用到Object中的声明的方法，因为变量o声明的类型就是Object。

注：java中的方法调用,是运行时动态和对象绑定的,不到运行的时候,是不知道到底哪个方法被调用的。

多态的好处与弊端

• 好处：提高了程序的拓展性

   具体表现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作
  

• 弊端：不能使用子类的特有功能

2、重写、重载和多态的关系

重载是编译时多态

调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错

重写是运行时多态

调用重写的方法，在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用，在运行 期间所指向
的对象是谁，这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用，是运行时动态和对象绑定
的)

3、多态的注意事项

1.多态是方法的多态，属性没有多态性。
2.编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是如 果两个没有关联的类进行强制转换，会报：ClassCastException。 比如：本来是狗，我把它转成猫。就会报这个异常。
3.多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

4、多态存在的条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象
  补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：

1.static方法，因为被static修饰的方法是属于类的，而不是属于实例的
2.final方法，因为被final修饰的方法无法被子类重写
3.private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被 protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢

5、方法绑定(method binding)

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定。

静态绑定：

在编译期完成，可以提高代码执行速度。

动态绑定：

通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。JAVA中除了final类、final方、static方法，所有方法都是JVM在运行期才进行动态绑定的。

多态：如果编译时类型和运行时类型不一致，就会造成多态。

6、instanceof和类型转换

1、instanceof

三个不同java文件

public class Person{
    public void run(){}
}

public class Student extends Person{
}

public class Teacher extends Person{
}

main：方法下

Object o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
System.out.println(o instanceof String);//false

Person o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
//编译报错
System.out.println(o instanceof String);

Student o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
//编译报错
System.out.println(o instanceof Teacher);
//编译报错
System.out.println(o instanceof String);

System.out.println(x instanceof Y);

【分析1】

该代码能否编译通过，主要是看声明变量x的类型和Y是否存在子父类的关系。有"子父类关"系就编译通过，没有子父类关系就是编译报错。

之后学习到的接口类型和这个是有点区别的。

【分析2】

输出结果是true还是false,主要是看变量x所指向的对象实际类型是不是Y类型的"子类型".

Object o = new Person();
System.out.println(o instanceof Student);//false
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
System.out.println(o instanceof String);//false

2、类型转换

public class Person{
    public void run(){}
}

public class Student extends Person{
    public void go(){}
}

public class Teacher extends Person{
}

为什么要类型转换

//编译报错,因为p声明的类型Person中没有go方法
Person p = new Student();
p.go();

//需要把变量p的类型进行转换
Person p = new Student();
Student s = (Student)p;
s.go();

//或者
//注意这种形式前面必须要俩个小括号
Person p = new Student();
((Student)p).go();

类型转换中的问题

//编译通过 运行没问题
Object o = new Student();
Person p = (Person)o;

//编译通过 运行没问题
Object o = new Student();
Student s = (Student)o;

//编译通过,运行报错
Object o = new Teacher();
Student s = (Student)o;

即: X x = (X)o;

运行是否报错，主要是变量o所指向的对象实现类型，是不是X类型的子类型，如果不是则运行就会报错。

【总结】

1.父类引用可以指向子类对象，子类引用不能指向父类对象。
2.把子类对象直接赋给父类引用叫向上转型（upcasting），不用强制转型。
如Father father = new Son();

3.把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
如father就是一个指向子类对象的父类引用，把father赋给子类引用son
即Son son =（Son） father；
其中father前面的（Son）必须添加，进行强制转换。
4.upcasting 会丢失子类特有的方法，但是子类overriding 父类的方法，子类方法有效
5.向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

修饰符

1、static修饰符

1、static变量
在类中,使用static修饰的成员变量,就是静态变量,反之为非静态变量。

静态变量和非静态变量的区别

静态变量属于类的，"可以"使用类名来访问，非静态变量是属于对象的，"必须"使用对象来访问。

public class Student{
    private static int age;
    private double score;
    public static void main(String[] args) {
        Student s = new Student();
        //推荐使用类名访问静态成员
        System.out.println(Student.age);
        System.out.println(s.age);
        
        System.out.println(s.score);
    }
}

静态变量对于类而言在内存中只有一个，能被类的所有实例所共享。实例变量对于类的每个实例都有一份, 它们之间互不影响。（在基础语法中粗略解释过静态变量）

public class Student {
    private static int count;
    private int num;

    public Student() {
        count++;
        num++;
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        Student s3 = new Student();
        Student s4 = new Student();
        //因为还是在类中,所以可以直接访问私有属性
        System.out.println(s1.num);//1
        System.out.println(s2.num);
        System.out.println(s3.num);
        System.out.println(s4.num);
        System.out.println(Student.count);
        
        System.out.println(s1.count);//4
        System.out.println(s2.count);
        System.out.println(s3.count);
        System.out.println(s4.count);
    }
}

在加载类的过程中为静态变量分配内存，实例变量在创建对象时分配内存，所以静态变量可以使用类名来直接访问，而不需要使用对象来访问。

2、static方法
在类中，使用static修饰的成员方法，就是静态方法，反之为非静态方法。

静态方法和非静态方法的区别

静态方法数属于类的，"可以"使用类名来调用，非静态方法是属于对象的，"必须"使用对象来调用。

静态方法"不可以"直接访问类中的非静态变量和非静态方法，但是"可以"直接访问类中的静态变量和静态方法
注意：this和super在类中属于非静态的变量.(静态方法中不能使用)

public class Student {
    private static int count;
    private int num;
    public void run(){}
    public static void go(){}
    public static void test(){
        //编译通过
        System.out.println(count);
        go();
        
        //编译报错
        System.out.println(num);
        run();
    }
}

非静态方法"可以"直接访问类中的非静态变量和非静态方法，也"可以"直接访问类中的静态变量和静态方法

public class Student {
    private static int count;
    private int num;

    public void run() {
    }

    public static void go() {
    }
    public void test() {
        //编译通过
        System.out.println(count);
        go();
        //编译通过
        System.out.println(num);
        run();
    }
}

思考：为什么静态方法和非静态方法不能直接相互访问？ 加载顺序的问题！

父类的静态方法可以被子类继承，但是不能被子类重写

public class Person {
    public static void method() {}
}

//编译报错
public class Student extends Person {
    public void method(){}
}

public class Person {
    public static void test() {
        System.out.println("Person");
    }
}
//编译通过,但不是重写
public class Student extends Person {
    public static void test(){
        System.out.println("Student");
    }
}

//main:
Perosn p = new Student();
p.test();//输出Person
p = new Person();
p.test();//输出Perosn

父类的非静态方法不能被子类重写为静态方法 ；

public class Person {
    public void test() {
        System.out.println("Person");
    }
}
//编译报错
public class Student extends Person {
    public static void test(){
        System.out.println("Student");
    }
}

3、代码块和静态代码块

【类中可以编写代码块和静态代码块】

public class Person {
    {
        //代码块(匿名代码块)
    }
    static{
        //静态代码块
    }
}

【匿名代码块和静态代码块的执行】

因为没有名字,在程序并不能主动调用这些代码块。

匿名代码块是在创建对象的时候自动执行的，并且在构造器执行之前，在静态代码块之后。同时匿名代码块在每次创建对象的时候都会自动执行。

静态代码块是在类加载完成之后就自动执行，并且只执行一次。

注：每个类在第一次被使用的时候就会被加载，并且一般只会加载一次。

public class Student {
    {
        System.out.println("匿名代码块");
    }
    
    static{
        System.out.println("静态代码块");
    }
    
    public Student(){
        System.out.println("构造器");
    }
}

//main:
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();

输出：

静态代码块 匿名代码块 构造器
匿名代码块 构造器
匿名代码块 构造器

【匿名代码块和静态代码块的作用】

匿名代码块的作用是给对象的成员变量初始化赋值，但是因为构造器也能完成这项工作，所以匿名代码块使用的并不多。

静态代码块的作用是给类中的静态成员变量初始化赋值。

public class Person {
    public static String name;
    static{
        name = "tom";
    }
    public Person(){
        name = "zs";
    }
}

注：在构造器中给静态变量赋值，并不能保证能赋值成功，因为构造器是在创建对象的时候才指向，但是静态变量可以不创建对象而直接使用类名来访问。

4、创建和初始化对象的过程

Student s = new Student();

【Student类之前没有进行类加载的过程】

1.类加载，同时初始化类中静态的属性
2.执行静态代码块
3.分配内存空间，同时初始化非静态的属性(赋默认值,0/false/null)
4.调用Student的父类构造器
5.对Student中的属性进行显示赋值(如果有的话)
6.执行匿名代码块
7.执行构造器
8.返回内存地址

注：子类中非静态属性的显示赋值是在父类构造器执行完之后和子类中的匿名代码块执行之前的时候

public class Person{
    private String name = "zs";
    public Person() {
        System.out.println("Person构造器");
        print();
    }
    public void print(){
        System.out.println("Person print方法: name = "+name);
    }
}

public class Student extends Person{
    private String name = "tom";
    {
        System.out.println("Student匿名代码块");
    }
    static{
        System.out.println("Student静态代码块");
    }
    public Student(){
        System.out.println("Student构造器");
    }
    public void print(){
        System.out.println("student print方法: name = "+name);
    }
    public static void main(String[] args) {
        new Student();
    }
}

输出：

Student静态代码块 Person构造器 student print方法: name = null Student匿名代码块 Student构造器

Student s = new Student();
//Student类之前已经进行了类加载
//1.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
//2.调用Student的父类构造器
//3.对Student中的属性进行显示赋值(如果有的话)
//4.执行匿名代码块
//5.执行构造器
//6.返回内存地址

5、静态导入

静态导包就是java包的静态导入，用import static代替import静态导入包是JDK1.5中的新特性。

意思是导入这个类里的静态方法。

好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一 个静态方法print(…)，在使用时直接print(…)就可以了。但是这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写来的方便。

2、final修饰符

1、修饰类

用final修饰的类不能被继承，没有子类

例如：我们是无法写一个类去继承String类，然后对String类型扩展的。因为API中已经被String类定义为final

我们也可以定义final修饰的类:

public final class Action{
    
}

//编译报错
public class Go extends Action{
    
}

2、修饰方法

用final修饰的方法可以被继承，但是不能被子类的重写。

例如：每个类都是Object类的子类，继承了Object中的众多方法，在子类中可以重写toString方法、equals方法等，但是不能重写getClass方法、wait方法等，因为这些方法都是使用fianl修饰的。

我们也可以定义final修饰的方法：

public class Person{
    public final void print(){}
}

//编译报错
public class Student extends Person{
    public void print(){
    }
}

3、修饰变量

用final修饰的变量表示常量，只能被赋一次值。使用final修饰的变量也就成了常量了，因为值不会再变了。

【修饰局部变量】

public class Person{
    public void print(final int a){
    //编译报错,不能再次赋值,传参的时候已经赋过了
    a = 1;
    }
}

public class Person{
    public void print(){
        final int a;
        a = 1;
        //编译报错,不能再次赋值
        a = 2;
    }
}

【修饰成员变量-非静态成员变量】

public class Person{
    private final int a;
}
/*
只有一次机会,可以给此变量a赋值的位置:
声明的同时赋值
匿名代码块中赋值
构造器中赋值(类中出现的所有构造器都要写)
*/

【修饰成员变量-静态成员变量】

public class Person{
    private static final int a;
}
/*
只有一次机会,可以给此变量a赋值的位置:
声明的同时赋值
静态代码块中赋值
*/

【修饰引用对象】

final Student s = new Student();
//编译通过
s.setName("tom");
s.setName("zs");

//编译报错,不能修改引用s指向的内存地址
s = new Student();

3、abstract修饰符

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法。如果修饰类，那么该类就是抽象类。

1、抽象类和抽象方法的关系

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

2、语法

public abstract class Action{
    public abstract void doSomething();
}

public void doSomething(){...}

对于这个普通方法来讲：

"public void doSomething()"这部分是方法的声明。 "{…}"这部分是方法的实现,如果大括号中什么都没写,就叫方法的空实现

声明类的同时，加上abstract修饰符就是抽象类 声明方法的时候，加上abstract修饰符，并且去掉方法的大口号，同时结尾加上分号，该方法就是抽象方法。

3、特点及作用
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

注：子类继承抽象类后，需要实现抽象类中没有实现的抽象方法，否则这个子类也要声明为抽象类。

public abstract class Action{
    public abstract void doSomething();
}

main:
//编译报错,抽象类不能new对象
Action a = new Action();

//子类继承抽象类
public class Eat extends Action{
    //实现父类中没有实现的抽象方法
    public void doSomething(){
        //code
    }
}

main:
Action a = new Eat();
a.doSomething();

注：子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

4、思考

思考1 : 抽象类不能new对象，那么抽象类中有没有构造器？

抽象类是不能被实例化，抽象类的目的就是为实现多态中的共同点，抽象类的构造器会在子类实例化时调用，因此它也是用来实现多态中的共同点构造，不建议这样使用！

思考2 : 抽象类和抽象方法意义（为什么要编写抽象类、抽象方法）

打个比方，要做一个游戏。如果要创建一个角色，如果反复创建类和方法会很繁琐和麻烦。建一个抽象类 后。
若要创建角色可直接继承抽象类中的字段和方法，而抽象类中又有抽象方法。如果一个角色有很多种 职业，每个
职业又有很多技能，要是依次实例这些技能方法会显得想当笨拙。定义抽象方法，在需要时继 承后重写调用，可以
省去很多代码。
总之抽象类和抽象方法起到一个框架作用。很方便后期的调用和重写 抽象方法是为了程序的可扩展性。
重写抽象方法时即可实现同名方法但又非同目的的要求。

接口

1、接口的本质
普通类：只有具体实现 抽象类：具体实现和规范(抽象方法) 都有！ 接口：只有规范！

为什么需要接口？接口和抽象类的区别？

• 接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
• 抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。
• 从接口的实现者角度看，接口定义了可以向外部提供的服务。
• 从接口的调用者角度看，接口定义了实现者能提供那些服务。
• 接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。

接口的本质探讨

• 接口就是规范，定义的是一组规则，体现了现实世界中”如果你是…则必须能…“的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。
• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
• OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

2、接口与抽象类的区别
抽象类也是类，除了可以写抽象方法以及不能直接new对象之外，其他的和普通类没有什么不一样的。接口已经另一种类型了，和类是有本质的区别的，所以不能用类的标准去衡量接口。

声明类的关键字是class，声明接口的关键字是interface。

抽象类是用来被继承的，java中的类是单继承。

类A继承了抽象类B，那么类A的对象就属于B类型了，可以使用多态 一个父类的引用，可以指向这个父类的任意子类对象 注：继承的关键字是extends

接口是用来被类实现的，java中的接口可以被多实现。 类A实现接口B、C、D、E…，那么类A的对象就属于B、C、D、E等类型了，可以使用多态 一个接口的引用，可以指向这个接口的任意实现类对象 注：实现的关键字是implements

3、接口中的方法都是抽象方法

接口中可以不写任何方法，但如果写方法了，该方法必须是抽象方法

public interface Action{
    public abstract void run();
    
    //默认就是public abstract修饰的
    void test();
    public void go();
}

4、接口中的变量都是静态常量

public static final修饰

接口中可以不写任何属性，但如果写属性了，该属性必须是public static final修饰的静态常量。 注：可以直接使用接口名访问其属性。因为是public static修饰的

注：声明的同时就必须赋值(因为接口中不能编写静态代码块)

public interface Action{
    public static final String NAME = "tom";
    //默认就是public static final修饰的
    int AGE = 20;
}

main:
System.out.println(Action.NAME);
System.out.println(Action.AGE);

5、一个类可以实现多个接口

public class Student implements A,B,C,D{
    //Student需要实现接口A B C D中所有的抽象方法
    //否则Student类就要声明为抽象类,因为有抽象方法没实现
}

main:
A s1 = new Student();
B s2 = new Student();
C s3 = new Student();
D s4 = new Student();

注： s1只能调用接口A中声明的方法以及Object中的方法 s2只能调用接口B中声明的方法以及Object中的方法 s3只能调用接口C中声明的方法以及Object中的方法 s4只能调用接口D中声明的方法以及Object中的方法

注：必要时可以类型强制转换

例如 : 接口A 中有test() ， 接口B 中有run()

6、一个接口可以继承多个父接口

public interface A{
    public void testA();
}

public interface B{
    public void testB();
}

//接口C把接口A B中的方法都继承过来了
public interface C extends A,B{
    public void testC();
}

//Student相当于实现了A B C三个接口,需要实现所有的抽象方法
//Student的对象也就同时属于A类型 B类型 C类型
public class Student implements C{
    public viod testA(){}
    public viod testB(){}
    public viod testC(){}
}

main:

C o = new Student();
System.out.println(o instanceof A);//true
System.out.println(o instanceof B);//true
System.out.println(o instanceof C);//true
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false

//编译报错
System.out.println(o instanceof String);

注：System.out.println(o instanceof X);

如果o是一个接口类型声明的变量，那么只要X不是一个final修饰的类，该代码就能通过编译，至于其结果是不是
true，就要看变量o指向的对象的实际类型，是不是X的子类或者实现类了。

注：一个引用所指向的对象，是有可能实现任何一个接口的。(java中的多实现)

7、接口的作用

接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建

【接口名】 【对象名】= new 【实现接口的类】

这样你像用哪个类的对象就可以new哪个对象了，不需要改原来的代码。

假如我们两个类中都有个function()的方法，如果我用接口，那样我new a()；就是用a的方法，new b() 就是用b的方法。

这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同

总结：

1.Java接口中的成员变量默认都是public,static,final类型的(都可省略)，必须被显示初始化，即接口中的成员变量为常量(大写,单词之间用"_"分隔)
2.Java接口中的方法默认都是public,abstract类型的(都可省略)，没有方法体,不能被实例化
3.Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法
4.接口中没有构造方法,不能被实例化
5.一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
Java接口必须通过类来实现它的抽象方法
6.当类实现了某个Java接口时，它必须实现接口中的所有抽象方法，否则这个类必须声明为抽象类
7.不允许创建接口的实例（实例化），但允许定义接口类型的引用变量，该引用变量引用实现了这个接口的类的实例
8.一个类只能继承一个直接的父类，但可以实现多个接口，间接的实现了多继承。

interface SwimInterface{
    void swim();
}

class Fish{
    int fins=4;
}

class Duck {
    int leg=2;
    void egg(){};
}

class Goldfish extends Fish implements SwimInterface {
    @Override
    public void swim() {
        System.out.println("Goldfish can swim ");
    }
}

class SmallDuck extends Duck implements SwimInterface {
    public void egg(){
        System.out.println("SmallDuck can lay eggs ");
    }
    @Override
    public void swim() {
  	  System.out.println("SmallDuck can swim ");
    }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Goldfish goldfish=new Goldfish();
        goldfish.swim();
        
        SmallDuck smallDuck= new SmallDuck();
        smallDuck.swim();
        smallDuck.egg();
    }
}

内部类

1、内部类概述

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

内部类不是在一个java源文件中编写俩个平行的俩个类，而是在一个类的内部再定义另外一个类。 我们可以把外边的类称为外部类，在其内部编写的类称为内部类。

内部类分为四种：

1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类

2、成员内部类

成员内部类（实例内部类、非静态内部类）

注：成员内部类中不能写静态属性和方法

【定义一个内部类】

//在A类中申明了一个B类，此B类就在A的内部，并且在成员变量的位置上，所以就称为成员内部类
public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类方法");
    }
    
    class Inner{
        public void in(){
     	   System.out.println("这是内部类方法");
        }
    }
}

【实例化内部类】

实例化内部类，首先需要实例化外部类，通过外部类去调用内部类

public class Outer {
    private int id;
    public void out(){
  	  System.out.println("这是外部类方法");
    }
    
    class Inner{
        public void in(){
        System.out.println("这是内部类方法");
    }
    }
}

public class Test{
    public static void main(String[] args) {
        //实例化成员内部类分两步
        //1、实例化外部类
        Outer outObject = new Outer();
        //2、通过外部类调用内部类
        Outer.Inner inObject = outObject.new Inner();
        //测试，调用内部类中的方法
        inObject.in();//打印：这是内部类方法
    }
}

分析：想想如果你要使用一个类中方法或者属性，你就必须要先有该类的一个对象，同理，一个类在另 一个类的内部，那么想要使用这个内部类，就必须先要有外部类的一个实例对象，然后在通过该对象去使用内部类。

【成员内部类能干什么？】

• 访问外部类的所有属性(这里的属性包括私有的成员变量，方法)

public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类方法");
    }
    
    class Inner{
        public void in(){
            System.out.println("这是内部类方法");
        }
        //内部类访问外部类私有的成员变量
        public void useId(){
            System.out.println(id+3);。
        }
        //内部类访问外部类的方法
        public void useOut(){
            out();
        }
    }
}

public class Test{
    public static void main(String[] args) {
        //实例化成员内部类分两步
        //1、实例化外部类
        Outer outObject = new Outer();
        //2、通过外部类调用内部类
        Outer.Inner inObject = outObject.new Inner();
        //测试
        inObject.useId();//打印3，因为id初始化值为0，0+3就为3，其中在内部类就使用了外部类的私有成员变量id。
        inObject.useOut();//打印：这是外部类方法
    }
}

• 如果内部类中的变量名和外部类的成员变量名一样，要通过创建外部类对象"."属性来访问外部类属性，通过this.属性访问内部类成员属性

public class Outer {
    private int id;//默认初始化0

    public void out() {
        System.out.println("这是外部类方法");
    }

    class Inner {
        private int id = 8; //这个id跟外部类的属性id名称一样。

        public void in() {
            System.out.println("这是内部类方法");
        }

        public void test() {
            System.out.println(id);//输出8，内部类中的变量会暂时将外部类的成员变量给隐藏
            // 如何调用外部类的成员变量呢？通过Outer.this
            // 想要知道为什么能通过这个来调用，就得明白下面这个原理
            // 想实例化内部类对象，就必须通过外部类对象，当外部类对象来new出内部类对象时，会把自己(外部类对象)的引用传到了内部类中，
            // 所以内部类就可以通过Outer.this来访问外部类的属性和方法
            // 到这里，你也就可以知道为什么内部类可以访问外部类的属性和方法，这里由于有两个相同的属性名称，

            // 所以需要显示的用Outer.this来调用外部类的属性，平常如果属性名不重复
            // 那么我们在内部类中调用外部类的属性和方法时，前面就隐式的调用了Outer.this。
            System.out.println(Outer.this.id);//输出外部类的属性id。也就是输出0
        }
    }
}

借助成员内部类，来总结内部类(包括4种内部类)的通用用法：

1.要想访问内部类中的内容，必须通过外部类对象来实例化内部类。

2.能够访问外部类所有的属性和方法，原理就是在通过外部类对象实例化内部类对象时，外部类对象把自己的引用传进了内部类，使内部类可以用通过Outer.this去调用外部类的属性和方法。

一般都是隐式调用了，但是当内部类中有属性或者方法名和外部类中的属性或方法名相同的时候，就需要通过显式调用Outer.this了。

【写的一个小例子】

public class MemberInnerClassTest {
    private String name;
    private static int age;

    public void run() {
    }

    public static void go() {
    }

    public class MemberInnerClass {
        private String name;

        //内部类访问外部类
        public void test(String name) {
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(MemberInnerClassTest.this.name);
            System.out.println(MemberInnerClassTest.age);
            MemberInnerClassTest.this.run();
            MemberInnerClassTest.go();
        }
    }

    //外部类访问成员内部类
    //成员内部类的对象要 依赖于外部类的对象的存在
    public void test() {
        //MemberInnerClass mic = MemberInnerClassTest.this.new MemberInnerClass();
        //MemberInnerClass mic = this.new MemberInnerClass();
        MemberInnerClass mic = new MemberInnerClass();
        mic.name = "tom";
        mic.test("hua");
    }

    public static void main(String[] args) {
        //MemberInnerClass mic = new MemberInnerClass();这个是不行的，this是动态的。
        //所以要使用要先创建外部类对象，才能使用
        MemberInnerClassTest out = new MemberInnerClassTest();
        MemberInnerClass mic = out.new MemberInnerClass();
        //如果内部类是private,则不能访问，只能铜鼓内部方法来调用内部类
        mic.name = "jik";
        mic.test("kkk");
    }
}

3、静态内部类

看到名字就知道，使用static修饰的内部类就叫静态内部类。

既然提到了static，那我们就来复习一下它的用法：一般只修饰变量和方法，平常不可以修饰类，但是内部类却可以被static修饰。

1.static修饰成员变量：整个类的实例共享静态变量
2.static修饰方法：静态方法，只能够访问用static修饰的属性或方法，而非静态方法可以访问static修饰的方法或属性
3.被static修饰了的成员变量和方法能直接被类名调用。
4.static不能修饰局部变量，切记，不要搞混淆了，static平常就用来修饰成员变量和方法。
例子：

public class StaticInnerClassTest {

    private String name;
    private static int age;

    public void run() {
    }

    public static void go() {
    }

    //外部类访问静态内部类
    public void test() {
        StaticInnerClass sic = new StaticInnerClass(); //静态的内部类不需要依赖外部类，所以不用this
        sic.name = "tom";

        sic.test1("jack");
        StaticInnerClass.age = 10;
        StaticInnerClass.test2("xixi");
    }

    private static class StaticInnerClass {
        private String name;
        private static int age;

        public void test1(String name) {
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(StaticInnerClass.age);
            System.out.println(StaticInnerClassTest.age);
            //System.out.println(StaticInnerClassTest.this.name);静态类不能访问非静态属性
            StaticInnerClassTest.go();
            //StaticInnerClassTest.this.run();静态类不能访问非静态方法
        }

        public static void test2(String name) {
            //只能访问自己和外部类的静态属性和方法
            System.out.println(name);
            //System.out.println(this.name);静态方法里面连自己类的非静态属性都不能访问
            System.out.println(StaticInnerClass.age);
            System.out.println(StaticInnerClassTest.age);
            //System.out.println(StaticInnerClassTest.this.name);静态方法不能访问非静态属性
            StaticInnerClassTest.go();
            //StaticInnerClassTest.this.run();静态方法不能访问非静态方法
        }
    }
}

注意：

1.我们上面说的内部类能够调用外部类的方法和属性，在静态内部类中就行了，因为静态内部类没有 了指向外部类对象的引用。除非外部类中的方法或者属性也是静态的。这就回归到了static关键字的用法。

2.静态内部类能够直接被外部类给实例化，不需要使用外部类对象

Outer.Inner inner = new Outer.Inner();

3.静态内部类中可以声明静态方法和静态变量，但是非静态内部类中就不可以声明静态方法和静态变量

4、局部内部类

局部内部类是在一个方法内部声明的一个类 局部内部类中可以访问外部类的成员变量及方法 局部内部类中如果要访问该内部类所在方法中的局部变量，那么这个局部变量就必须是final修饰的

public class Outer {
    private int id;

    //在method01方法中有一个Inner内部类，这个内部类就称为局部内部类
    public void method01() {
        class Inner {
            public void in() {
                System.out.println("这是局部内部类");
            }
        }
    }
}

局部内部类一般的作用跟在成员内部类中总结的差不多，但是有两个要注意的地方：

1、在局部内部类中，如果要访问局部变量，那么该局部变量要用final修饰

为什么需要使用final？

final修饰变量：变为常量，会在常量池中放着，逆向思维想这个问题，如果不实用final修饰，当局部内部类被实例化后，方法弹栈，局部变量随着跟着消失，这个时候局部内部类对象在想去调用该局部变量，就会报错，因为该局部变量已经没了，当局部变量用fanal修饰后，就会将其加入常量池中，即使方法弹栈了，该局部变量还在常量池中呆着，局部内部类也就是够调用。所以局部内部类想要调用局部变 量时，需要使用final修饰，不使用，编译度通不过。

public class Outer {
    private int id;

    public void method01() {
        //这个就是局部变量cid。要让局部内部类使用，就得变为final并且赋值，如果不使用final修饰，就会报错
        final int cid = 3;
        class Inner {
            //内部类的第一个方法
            public void in() {
                System.out.println("这是局部内部类");
            }

            //内部类中的使用局部变量cid的方法
            public void useCid() {
                System.out.println(cid);
            }
        }
    }
}

2、局部内部类不能通过外部类对象直接实例化，而是在方法中实例化出自己来，然后通过内部类对象 调用自己类中的方法。

看下面例子就知道如何用了。

public class Outer {
    private int id;

    public void out() {
        System.out.println("外部类方法");
    }

    public void method01() {
        class Inner {
            public void in() {
                System.out.println("这是局部内部类");
            }
        }
        //关键在这里，如需要在method01方法中自己创建内部类实例，
        // 然后调用内部类中的方法，等待外部类调用method01方法，
        // 就可以执行到内部类中的方法了。
        Inner In = new Inner();
        In.in();
    }
}

使用局部内部类需要注意的地方就刚才上面说的：

1.在局部内部类中，如果要访问局部变量，那么该局部变量要用final修饰

2.如何调用局部内部类方法。

public class LocalInnerClassTest {
    private String name;
    private static int age;

    public void run() {
    }

    public static void go() {
    }

    //局部内部类要定义在方法中
    public void test() {
        final String myname = "";
        class LocalInnerClass {
            private String name;

            // private static int age;不能定义静态属性
            public void test(String name) {
                System.out.println(name);
                System.out.println(this.name);
                System.out.println(myname);
                System.out.println(LocalInnerClassTest.this.name);
                LocalInnerClassTest.this.run();
                LocalInnerClassTest.go();
            }
        }
        // 局部内部类只能在自己的方法中用
        // 因为局部内部类相当于一个局部变量，出了方法就找不到了。
        LocalInnerClass lic = new LocalInnerClass();
        lic.name = "tom";
        lic.test("test");
        
    }
    
}

5、匿名内部类

在这四种内部类中，以后的工作可能遇到最多的是匿名内部类，所以说匿名内部类是最常用的一种 内部类。

什么是匿名对象？如果一个对象只要使用一次，那么我们就是需要new Object().method()。 就可以了，而不需要给这个实例保存到该类型变量中去。这就是匿名对象。

public class Test {
    public static void main(String[] args) {
        //讲new出来的Apple实例赋给apple变量保存起来，但是我们只需要用一次，就可以这样写
        Apple apple = new Apple();
        apple.eat();
        //这种就叫做匿名对象的使用，不把实例保存到变量中。
        new Apple().eat();
    }
}

class Apple{
    public void eat(){
        System.out.println("我要被吃了");
	}
}

匿名内部类跟匿名对象是一个道理：

匿名对象：我只需要用一次，那么我就不用声明一个该类型变量来保存对象了，

匿名内部类：我也只需要用一次，那我就不需要在类中先定义一个内部类，而是等待需要用的时候，我就在临时实现这个内部类，因为用次数少，可能就这一次，那么这样写内部类，更方便。不然先写出一 个内部类的全部实现来，然后就调用它一次，岂不是用完之后就一直将其放在那，那就没必要那样。

1.匿名内部类需要依托于其他类或者接口来创建
如果依托的是类，那么创建出来的匿名内部类就默认是这个类的子类
如果依托的是接口，那么创建出来的匿名内部类就默认是这个接口的实现类。
2.匿名内部类的声明必须是在使用new关键字的时候
匿名内部类的声明及创建对象必须一气呵成，并且之后能反复使用，因为没有名字

【示例】
A是一个类(普通类、抽象类都可以)，依托于A类创建一个匿名内部类对象

main:

A a = new A(){
    //实现A中的抽象方法
    //或者重写A中的普通方法
};

注:这个大括号里面其实就是这个内部类的代码,只不过是声明该内部类的同时就是要new创建了其对象,
并且不能反复使用,因为没有名字。
    
例如:
B是一个接口，依托于B接口创建一个匿名内部类对象

B b = new B(){
	//实现B中的抽象方法
};

1.匿名内部类除了依托的类或接口之外，不能指定继承或者实现其他类或接口，同时也不能被其他类所继承，因为没有名字。
2.匿名内部中，我们不能写出其构造器，因为没有名字。
3.匿名内部中，除了重写上面的方法外，一般不会再写其他独有的方法，因为从外部不能直接调用到。(间接是调用到的)

public interface Work{
    void doWork();
}

public class AnonymousOutterClass{
    private String name;
    private static int age;
    public void say(){}
    public static void go(){}
    
    public void test(){
        final int i = 90;
        
        Work w = new Work(){
            public void doWork(){
                System.out.println(AnonymousOutterClass.this.name);
                System.out.println(AnonymousOutterClass.age);
                AnonymousOutterClass.this.say();
                AnonymousOutterClass.go();
                
                System.out.println(i);
            }
        };
        w.doWork();
    }
}

我们可以试一下不 用匿名内部类 和 用匿名内部类 实现一个接口中的方法的区别

【不用匿名内部类】

public class Test {
    public static void main(String[] args) {
        // 如果我们需要使用接口中的方法，我们就需要走3步，
        // 1、实现接口 2、创建实现接口类的实例对象 3、通过对象调用方法
        //第二步
        Test02 test = new Test02();
        //第三步
        test.method();
    }
}

//接口Test1
interface Test01{
    public void method();
}

//第一步、实现Test01接口
class Test02 implements Test01{
    @Override
    public void method() {
        System.out.println("实现了Test接口的方法");
    }
}

【使用匿名内部类】

public class Test {
    public static void main(String[] args) {
		//如果我们需要使用接口中的方法，我们只需要走一步，就是使用匿名内部类，直接将其类的对象创建出来。
        new Test1(){
            public void method(){
                System.out.println("实现了Test接口的方法");
            }
        }.method();
    }
}

interface Test1{
    public void method();
}

解析：

其实只要明白一点，new Test1( ){ 实现接口中方法的代码 };

Test1(){…} 这个的作用就是将接口给实现了，只不过这里实现该接口的是一个匿名类，也就是说这个类没名字，只能使用这一次，我们知道了这是一个类， 将其new出来，就能获得一个实现了Test1接口的类的实例对象，通过该实例对象，就能调用该类中的方法了，因为其匿名类是在一个类中实现的，所以叫其匿名内部类。