day2.28~ 【final、权限、内部类、引用类型】复习

第一章 final关键字

定义：

final ： 不可改变。可以用于修饰类、方法和变量。
类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。

使用方法：

一、修饰类

public final class 类名称{}

注意事项：
1.被final修饰的类不能再有任何子类，他就是一个太监类。
2.final类当中的所有成员方法都无法被覆盖重写。
二、修饰方法

public final 返回值类型 方法名称（）{}

注意事项：
1.sbstract与final两个关键字不能同时使用，抽象方法一定要覆盖重写，而final方法一定无法被覆盖重写。
三、修饰局部变量
final 参数类型 参数名称；
注意事项：一旦被修饰无法更改。
1.当参数类型为基本类型时，无法更改的是数据值。
2.当数据类型是引用类型的时候，无法修改的是返回值，而其内容可以修改；
例如：

final Person person = new Person()；
person.setName("高圆圆")；
//person =new Person("赵又廷")；//

这是一种错误写法，因为同一个Person person 的地址值一样，而再new一次，就是一个新的对象，新的地址值，这时候再赋值给原来的Person person 意思是要修改地址值，而其实不能这么做。
但可以修改内容：

person.setName("高圆圆圆又圆")；
sout("person.getName");

四、修饰成员方法
1.因为成员方法有默认值，所以在用final 修饰时候一定要手动赋值。
2.要么通过构造方法赋值，要么直接赋值。
3.必须保证类当中的所有重载构造方法都最终对final的成员变量赋值。

public class Person {

    private final String name/* = "鹿晗"*/;

    public Person() {
        name = "关晓彤";
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

//    public void setName(String name) {
//        this.name = name;
//    }
}

第二章 权限修饰符

2.1 概述
在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，
public ：公共的。
protected ：受保护的
default ：默认的
private ：私有的
2.2 不同权限的访问能力

第三章 内部类

访问特点

1.内部类可以直接访问外部类的成员，包括私有成员。
2.外部类要访问内部类的成员，必须要建立内部类的对象。
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
定义类：

public class Person {
    private  boolean live = true;
    class Heart {
        public void jump() {
            // 直接访问外部类成员
            if (live) {
                System.out.println("心脏在跳动");
            } else {
                System.out.println("心脏不跳了");
            }
        }
    }
    public boolean isLive() {
        return live;
    }
    public void setLive(boolean live) {
        this.live = live;
    }
}

定义测试方法：

public class InnerDemo {
public static void main(String[] args) {
        // 创建外部类对象
        Person p  = new Person();
        // 创建内部类对象
        Heart heart = p.new Heart();
        // 调用内部类方法
        heart.jump();
        // 调用外部类方法
        p.setLive(false);
        // 调用内部类方法
        heart.jump();
    }
}
输出结果:
心脏在跳动
心脏不跳了

3.内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的 .class文件，但是前面冠以外部类的类名和$符号。比如，Person$Heart.class

匿名内部类【重点】

匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 【父类或者父接口】的 匿名的 子类对象。
前提
匿名内部类必须继承一个父类或者实现一个父接口。
格式

new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {
        // 执行语句
    }
};

==================================
定义接口

public abstract class FlyAble{
    public abstract void fly();
}

定义匿名对象

public class InnerDemo {
    public static void main(String[] args) {
        /*
        1.等号右边:是匿名内部类，定义并创建该接口的子类对象
        2.等号左边:是多态赋值,接口类型引用指向子类对象
        */
        FlyAble  f = new FlyAble(){
            public void fly() {
                System.out.println("我飞了~~~");
            }
        };
        //调用 fly方法,执行重写后的方法
        f.fly();
    }
}