多态，父类的延伸

• 引用多态

        父类的引用，指向本类对象

        Animal animal = new Animal();

        父类的引用，指向子类对象

        Animal animal2 = new Dog();

• 方法多态

        创建本类对象时，调用本类的方法

        创建子类对象时，调用继承或重写父类的方法，不能调用子类独有的方法

equals方法。

equals方法判断的是两个对象引用的内存地址是否相同

==

==判断的是两个基本数据类型的数据值是否相同

Object类是所有类的父类

如果在类的主函数中，直接输出一个对象，那么输出的将是对象在内存中的地址，即哈希码

public static void main (String[] args){

    Animal animal = new Animal();

    System.out.println(animal);

}

在类中重写toString()方法可以输出对象的属性值

@Override

public Sting toString(){

    return "Animal [animal"+animal+"]";

}

super关键字

子类可以使用super.property、super.method()来调用父类的属性和方法

如果子类方法中没有显示地调用父类的构造方法，在创建子类对象的时候，会隐性地执行父类无参的构造方法，相当于在子类构造方法中的第一行写了super();

如果子类方法中显示地调用了父类的构造方法，必须放在子类构造方法的第一行

如果父类中有有参的构造方法，那么父类不会默认创建无参的构造方法。此时如果子类中不显示地调用父类中的构造方法，那么编译器会报错

final关键字。

死刑宣告

final可以修饰类、方法、变量

final修饰类，该类不能被继承

final public class Animal(){
}

final修饰方法，该方法不能被重写或覆盖

final public void eat(){
}

final修饰属性，该属性值不能被更改。

定义成员变量的时候是可以不用赋初值的，定义局部变量一定要赋初值。

当final修饰成员变量且没有赋值的时候，系统不会自动帮成员变量初始化，编译器会报错，所以final修饰成员变量要给变量赋初值或者可以在构造方法中给成员变量赋初值

当final修饰局部变量的时候，局部变量相当于敞亮，变量值不能被更改

final private static String name = "阿飞";

或

final private static String name;
public HelloWorld(){
name = "阿飞"
}

虎父无犬子

方法的重写。

子类在继承父类的时候，可以在本类中对父类的方法进行修改以更适用于子类，在调用时会优先调用子类中重写的方法

重写的方法，要与父类的方法名、返回值类型、参数类型及个数都相同

创建其他类的时候，在类名后加上extends关键字和要继承的类名，表示继承本类，可以使用本类的属性和方法，即完成了代码的复用

public class Dog extends Animal(){
}

父类中变量或方法有private修饰时，由于private的作用域只限本类，所以子类无法继承父类中private修饰的变量或方法的

方法内部类。

定义在外部类的方法中的类，所以就限制了只能在该方法的内部使用，也就不能用访问控制符和static修饰

使用内部类中的方法，就是使用外部类的方法中的内部类的方法

public class MethodOuter(){
     //外部类的成员变量
     private String name = "慕课";
      //外部类的方法
     public void show(){
        //外部类方法的内部类
        class MethodInner(){
            //内部类的变量
            int score = 90;
            //内部类的方法
            public int getScore(){
                return  score + 10;
                }
            }
            //创建内部类对象
            MethodInner methodInner= new MehthodInner();
           //调用内部类的方法
            int newScore = methodInner.getScore();
            System.out.println("名字："+name);
            System.out.println("成绩："+newScore);
    }
    public static void main (String[] args){
        MethodOuter methodOuter = new MethodOuter();
        methodOuter.show();
    }
}

静态内部类。

与外部类的静态成员变量放在同一位置

创建静态内部类对象的时候，省去了先创建外部类的对象的步骤

Inner inner = new Inner();

静态内部类调用外部类的静态方法或静态变量的时候，直接用就得了，

如果内部类与外部类有同名的变量或方法，此时直接用表示内部类的，通过外部类.变量或方法表示外部类的

静态内部类调用外部类的非静态变量或非静态方法时，也要先new一个外部类的非静态变量或非静态方法

public class Outer(){
    //外部类的非静态变量
    private int a = 1;
    //外部类的静态变量
    private static int b = 2;
        //静态内部类
        public static class Inne(){
        //静态内部类的非静态变量
        int a = 3;
        //静态内部类的静态变量
        static int b = 4;
        public void test(){
        System.out.println("访问外部类中的b："+Outer.b);
        System.out.println("访问内部类中的b："+b);
        }    
    //测试内部类
    public static void main (String[] args){
    //直接创建静态内部类的对象
    Inner inner = new Inner();
    //调用静态内部类的test方法
    inner.test();
    }
}

作用域  类和方法使用

初始值   是否赋予初始值

同种方法不可同名，不同方法不影响

局部变量优先

 interface  i = interface(){

           public void  name(

               实现接口里的方法

            )

     };

     i.接口中的方法  来调用

     new interface(){}.方法 （第二种写法）

     1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

     2、匿名内部类中是不能定义构造函数的。

     3、匿名内部类中不能存在任何的静态成员变量和静态方法。

      4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

     5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

成员内部类

在代码中，与外部类的成员变量在同一位置，所以称为成员内部类

内部类，为了更好的封装。Inner隐藏在Outer里面，同一包中的其他类也无法访问到Inner

Inner可以使用Outer的所有数据，不受访问控制符限制，相当于控制中心。

Outer不能随便使用Inner的变量和方法

Inner所实现的功能使用外部类同样可以实现，只是有时用Inner会更方便

创建一个类HelloWorld

public HelloWorld(){
}

给HelloWorld添加一个内部类Inner

public HelloWorld(){
    public Inner(){
        public void show(){
        }
    }
}

调用内部类的时候，需要先创建外部类的对象，再通过外部类创建的对象来创建内部类的对象

HelloWorld hello = new HelloWorld();
Inner inner = hello.new Inner();

调用内部类

inner.show();

类 = class 组织单元     组成 ：属性和方法

public class  类名{  }

1命名  2 有什么  3干什么