7.面向对象（三）抽象类、接口

一、Final关键字
(1)修饰变量
a.final修饰变量，变量值不可以改变，首字母大写

 //final修饰一个变量，变量值不可以改变，这个变量就变成了一个字符常量，首字母大写
        final int A=10;
        Dog d=new Dog();//final修饰引用数据类型，地址将不会在改变
        //d=new Dog();//地址值不改变;

b.对象的属性依旧可以改变

//对象的属性依然可以改变
        d.age=19;
        d.weight=120;片

c.

 final Dog d2=new Dog();
        a(d2);
        public static void a(Dog d){
        d=new Dog();
        }

d.

final Dog d2=new Dog();
a(d2);
public static void b(final Dog d){//final修饰，指向不可以改变
 //d=new Dog();

(2)修饰方法
final 修饰方法，这个方法不可以在子类中进行重写
(3)修饰类
final 修饰类，代表没有子类，该类不可以被继承，类被final修饰里面的方法不需要再用final修饰
(4)JDK提供的math类
a.使用math无需导包直接使用

package java.lang

b.math没有子类，不能被其他类继承

public final class Math(){
}

c.里面的属性全部被final修饰，方法也被final修饰，省略不写，原因：子类不需要重写
d.外界不可以创建对象

private Math()；//构造器私有化

e.Math类中的所有属性，方法都被static修饰 ，只能通过类名.属性名或类名.方法名调用
二、抽象类、抽象方法
1.抽象类和抽象方法的关系
抽象类可以定义0-n个抽象方法
2.抽象类的作用
在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类中的抽象方法，然后可以扩展自己的内容，抽象设计避免了子类设计的随意性
代码：

//4.一个类中如果是抽象方法，那么这个类也要变成一个抽象类
//5.一个抽象类中可以有0-n个抽象方法
public abstract class Person {
    //1.子类堆方法十分满意，直接使用
    public void eat(){
        System.out.println("吃饭");
    }
    //2.子类方法永远不满意，对方法重写
    //3.方法体去掉，然后用abstract修饰，就会变成一个抽象方法
    public abstract void say();
    public abstract void sleep();
    /*public void say(){
        System.out.println("全世界都在说中国话");
    }*/
    //6.抽象类可以被其他类继承
    //7.一个类继承一个抽象类，那么这个类可以变成一个抽象类
    //8.一般子类不会用abstract修饰，一般会让子类重写父类中的抽象类
    //9.子类继承抽象类，就必须重写全部的抽象方法
    //10.子类如果没有重写全部的抽象方法，就必须在子类的前面加上abstract；
    static class Student extends Person{
        @Override
        public void say() {
            System.out.println("武侯人说武侯话");
        }

        @Override
        public void sleep() {
            System.out.println("睡觉");
        }
    }
    static class Demo{
        public static void main(String[] args) {
            //11.抽象类不可以创建对象
            //Person p=new Person;
            // 12.创建子类对象
            Student s=new Student();
            s.say();
            s.sleep();
            //多态的写法，父类引用指向子类对象
            Person p=new Student();
            p.eat();
            p.say();
        }
    }
    }

（1）抽象类不能创建对象，那么抽象类中是否有构造器？
抽象类中一定有构造器，构造器的作用给子类初始化对象的时候要先super调用父类构造器
（2）抽象类是否可以被final修饰？
不可以，抽象类设计的初衷是给子类继承用，被final修饰后就不能进行继承了
三、接口
1.JDK1.8前
（1）代码

1.类和接口是不同的概念，他们是同一层次
2.接口中没有构造器
3.接口如何声明：interface
4.JDK1.8之前，接口中只有俩部分内容
（1）常量：固定修饰符：public static final
（2）抽象方法:固定修饰符：public abstract
修饰符可省略不写
  */
public interface TestInterface {
    //常量
    public static final int NUM=10;
    //抽象方法
    public abstract void a();
    public abstract void b(int num);
    public abstract int c(String name);
}
interface TestInterface1{
    //常量
    public static final int AGE=12;
    //抽象方法
    public abstract void d();
}
/*5.类和接口之间的关系：类实现接口
6.一旦实现是一个接口，那么实现的类需要重写接口中的全部抽象方法
7.没有实现全部全部抽象方法，这个类需要变成一个抽象类
8.Java只有单继承，Java还有多实现
一个类继承其他类只能继承一个类
但是实现接口，可以实现多个接口
9.先继承，再实现class Student extends Person implements TestInterface,TestInterface1{
 */
class Student extends Person implements TestInterface,TestInterface1{

    @Override
    public void a() {
        System.out.println("1111");
    }

    @Override
    public void b(int num) {
        System.out.println("2222");
    }

    @Override
    public int c(String name) {
        return 0;
    }
    public void d(){
        System.out.println("3333");
    }
}
class Test{
    public static void main(String[] args) {
        //10.接口不可以创建对象
        //TestInterface t=new TestInterface();
        //接口具体实现类可以创建对象
        TestInterface t=new Student();//接口指向实现类，多态
        //11.接口中的常量可以用接口.常量名或者接口实现类.常量名
        System.out.println(TestInterface.NUM);
        System.out.println(Student.NUM);
        Student s=new Student();
        System.out.println(s.NUM);
        TestInterface t1=new Student();
        System.out.println(t1.NUM);
    }
}

（2）接口的作用
定义规则：接口定义好，实现类负责实现即可
（3）继承
继承：子类对父类的继承
实现：实现类对接口的实现
（4）多态应用场合
a.父类当作方法的形参，传入具体的子类对象
b.父类当作方法的返回值，返回值是具体的子类的对象
c.接口当作方法的形参，传入具体的实现类的对象
d.接口当作方法的返回值，返回的是具体的实现类的对象
（5）接口和抽象类的区别

抽象类：1、抽象类使用abstract修饰；2、抽象类不能实例化，即不能使用new关键字来实例化对象；3、含有抽象方法（使用abstract关键字修饰的方法）的类是抽象类，必须使用abstract关键字修饰；4、抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以有具体的方法；5、如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类；6、抽象类中的抽象方法只有方法体，没有具体实现；

接口：1、接口使用interface修饰；2、接口不能被实例化；3、一个类只能继承一个类，但是可以实现多个接口；4、接口中方法均为抽象方法；5、接口中不能包含实例域或静态方法（静态方法必须实现，接口中方法是抽象方法，不能实现）

2.JDK1.8后新增方法
（1）被public default修饰的非抽象方法
a.default修饰符必须要加
b.实现类中想要重写非抽象方法，default必须要加
（2）静态方法
静态方法不可以重写
为什么在接口中加入静态方法？

//常量
    public static final int NUM=10;
    //抽象方法
    public abstract void a();
    //非抽象方法
    public default void b(){
        System.out.println("非抽象方法");
    }
    //静态方法
    public static void c(){
        System.out.println("静态方法");
    }

四、内部类
1.成员内部类
(1)类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
(2)内部类：局部内部类，（方法类，块类，构造器类）成员内部类
(3)成员内部类：属性，方法，构造器
修饰符private public default protect final
(4)内部类可以访问外部类的属性、方法等
(5)静态内部类不可以访问外部类的非static修饰的属性方法
(6)外部类要访问内部内，可以通过创建内部类对象访问内部类的属性和方法
(7)内部类和外部类属性重名的时候如何进行调用
(8)外部类、静态内部类、非静态内部类如何创建对象

/*
1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
 2.内部类：局部内部类，（方法类，块类，构造器类）成员内部类
 3.成员内部类：属性，方法，构造器
 修饰符private public default protect final
 4.内部类可以访问外部类的属性、方法等
 5。静态内部类不可以访问外部类的非static修饰的属性方法
 6.外部类要访问内部内，可以通过创建内部类对象访问内部类的属性和方法
 7.内部类和外部类属性重名的时候如何进行调用

*/

public class TestOuter {
    //成员内部类
    class B{
        int age=20;
        String name;
        public  void d(){
            int age=30;
            System.out.println(age);//30
            System.out.println(this.age);//20
            System.out.println(TestOuter.this.age);//30
            a();
        }
    }
    B b=new B();

    //静态内部类
    static class  c{
        int age;

    }
    //属性
    int age=10;
    //方法
    public void a(){
        {
            System.out.println("普通块");
        }
    }
    {
        System.out.println("构造块");   //先是构造块在是构造器
    }
    static {
        System.out.println("静态块");//静态块最先加载
    }
    //空构造器构造器
    public TestOuter() {
    }

    //
}
class Test{
    public static void main(String[] args) {
        //创建外部类对象
        TestOuter to=new TestOuter();
        //创建非静态成员内部类对象
        TestOuter t=new TestOuter();
        TestOuter.B b=t.new B();
        //创建静态成员内部类对象
        TestOuter.c C=new TestOuter.c();
    }
}

2.局部内部类