匿名对象:
。当对象只被调用一次方法时，使用匿名对象
。当对象作为参数传递时，使用匿名对象

封装
。将多个相似功能的写在一个类中
一、多态
。在多态的情况下，子类如果重写了父类的方法，那么无论如何执行的都是
子类的方法（全遮挡）
1、定义：
。一个事物的多种形态
2、多态的前提：
。要有子父类关系
。要有方法重写
。要有父类引用指向子类对象

pulic class Father{
    public void method(){
        System.out.println("父类method方法");
    }
}

//子类继承父类

public class Son extends Father{
    //重写父类的方法
    public void method(){
        System.out.println("子类的method方法");
    }
}

public static void main(String[] args){
    //父类类型的变量引用子类类型的实例对象
    Father father = new Son();
    father.method();
}

3、注意事项
。可以做哪些工作看父类类型
。实际做工作的看子类对象
。优点：提高了代码的扩展性、复用性、可以当做形参，用来
接受任意类型的子类对象
。缺点：不能使用子类的特有属性和方法
4、演示：
。学校有授课功能，但是需要聘请老师讲课，编程模拟

public class School{
    
    public void teach(Teacher teacher){
        teacher.teach();
    }
}

public class Teacher{
    public void teach(){
        System.out.println("老师上课");
    }
}

public class MusicTeacher extends Teacher{
    public void teach(){
        System.out.println("没有的歌声从教室传来");
    }
}

public class MathTeacher extends Teacher{
    public void teach(){
        System.out.println("认真的讲解每一个运算步骤");
    }
}

public statcic void main(String[] args){
    School s = new School();
    //调用学校的授课功能，传递一个音乐老师过去
    s.teach(new MusicTeacher());
    //调用学校的授课功能，传递一个数学老师过去
    s.teach(new MathTeacher());
}

二、多态成员访问的特点
1、成员变量
。编译看左边（父类），运行看左边（父类）（静态绑定）
。一般情况使用极少，成员变量一般都是私有化的

2、成员方法
。编译看左边（父类），运行看右边（子类），动态绑定
。能执行哪些方法看左边的父类类型，具体执行哪个方法，看子类对象

3、静态方法
。编译看左边（父类），运行开左边（父类）

三、多态转型
1、向上转型
。将子类对象看作是父类类型，也就是我们平时使用的多态形式
。这种情况下，无法调用子类特有的功能
2、向下转型
。将父类引用指向的子类对象再转回子类类型
四、final关键字
1、定义：
。final表示最终的，无法被修改的

2、final修饰的特点：
。修饰类，类不能被继承
。修饰变量，变量就变成了常量，只能被赋一次值（初始化时候赋值）
。修饰方法，方法不能被重写

3、final修饰局部变量
。基本数据类型，是值不能被改变
。引用数据类型，是地址值不能被改变，对象中的属性可以改变
。fianl可以修饰形参

4、final修饰成员变量的初始化时机
。必须手动赋值
。对象初始化完毕之前
。类初始化完成前（静态）

五、抽象类：记录业务，思考过程
。抽样类的非抽象方法：一般是核心业务
1、定义：
。抽象类没有具体的代码实现，只是规定了方法的基本属性，然后由
子类区去实现具体的代码，抽象类主要是为了定义规则而存在的。
2、特点：
。抽象类和抽象方法必须用abstract关键字修饰
。abstract class 类名{}
。abstract 返回值类型 方法名（）；
。抽象方法就是指一个没有具体代码的方法，没有大括号，以； 号
结束，必须以abstract来表表明当前是一个抽象类
。如果一个类中有抽象方法，那么这个类必须是抽象的，是为了
安全。
。加了abstract关键字的类，不予许创建对象
。抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者接口
。抽象类不能实例化，必须有子类继承并重写抽象方法来实现
。抽象类的子类
。要么是抽象类
。要么重写抽象类中的所有抽象方法（普通类）

3、抽象类成员方法的特点
。抽象方法，强制要求子类做的事情
。非抽象方法，子类继承的方法，提高代码的复用性
4、优点：
。强制子类实现父类的方法功能
。提高代码的扩展性，便于后期的维护
。形成一套规范（重点）
5、定义抽象类的过程，我们一般称之为定义规则的过程

六、java值传递的三种方式
1、基本数据类型值得传递
。基本数据类型传递的是值，也就是将具体的值赋给变量名，所以变量
名代表的是具体的值
2、引用数据类型传递的是地址值
。当一个对象赋值给一个对象名，是将这个对象再内存中的地址值传递
给对象名
。实例对象再堆内存中是一个16进制的地址值
3、String值得传递
。String比较特殊，它虽然是一个引用变量，但是它传递的是具体的数
值
。String首先是在堆内存中创建一个对象，对象里面封装的是常量值
然后将数值放入到常量池中，再指向String
4、总结：
。基本数据类型传递的是值，引用数据类型传递的是址
七、接口
1、定义
。接口其实就是抽象类的升级版，接口里面都是抽象方法
。从狭义上来讲，接口就是值java中的interface
。从广义还是那个的角度讲对外提供规则的都是接口
。作用：制定规则
2、特点：
。接口：比较纯粹的抽象类的简写形式
。接口关键字interface表示
。interface接口名{}
。接口中方法上的abstract关键字可以省略
。类实现接口用implements表示
。class 类名 implements 接口名{}
。接口不能实例化
。接口按照多态的方法实例化
。接口的子类
。可以是接口，使用extends来继承
。可以使抽象类，但意义不大
。可以是实体类，要重写接口中的所有抽象方法（主要使用）
。接口中的成员变量必须是静态的 最终 公共，也就是常量
。static、fianl 关键字可以省略（建议省略）
。接口可以继承接口
//接口1

public interface MyInterface{
    //定义了静态变量static final 可以省略
    static final String NAME = "小红";
    //定义了抽象方法
    public void method();
    //定义了抽象方法
    public void method2();
}

//接口 2 继承了接口1
public interface MyInterface2 extends MyInterface{
    //定义了抽象方法
    public void method2();
}
//定义实现类实现接口
public class MyInterfaceSon implements MyInterface2{
    //重写抽象方法
    @Override
    public void method(){
        System.out.println("重写method抽象方法");
    }
    //重写抽象方法
    @Override 
    public void method2(){
        System.out.println("重写method2抽象方法");
    }
}

八、类、接口之间的关系
1、类与类
。继承关系，只能单继承，不能多继承，但是可以多层继承
。多层继承：子类继承父类，父类继承父类
。如果多个父类出现相同的方法，无法区别
2、类与接口
。实现关系，可以单实现，也可以多实现，在继承类的同时，可以多实
现
。多个接口中出现了名称和参数列表相同的方法，但是返回值不同，会
报错
3、接口与接口
。继承关系，可以单继承，也可以多继承
。如果多个父类中出现了相同的，子类用谁的都可以