8.final、权限、内部类、引用类型

final、权限、内部类、引用类型

第一章 final关键字

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承
API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。

final：不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。

常见四种用法：
1… 可以用来修饰一个类
2… 可以用来修饰一个方法
3… 还可以用来修饰一个局部变量
4… 还可以用来修饰一个成员变量

当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {
// …
}

含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）

public final class MyClass /*extends Object*/ {public void method() {System.out.println("方法执行！");}
}

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型方法名称(参数列表) {
// 方法体
}

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

public abstract class Fu {public final void method() {System.out.println("父类方法执行！");}public abstract /*final*/ void methodAbs() ;
}

public class Zi extends Fu {@Overridepublic void methodAbs() {}// 错误写法！不能覆盖重写父类当中final的方法
//    @Override
//    public void method() {//        System.out.println("子类覆盖重写父类的方法！");
//    }
}

修饰一个局部变量;
对于基本类型来说，不可变说的是变量当中的数据不可改变
对于引用类型来说，不可变说的是变量当中的地址值不可改变，但是地址对应的值是可以改变的

public class Demo01Final {public static void main(String[] args) {int num1 = 10;System.out.println(num1); // 10num1 = 20;System.out.println(num1); // 20// 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。// “一次赋值，终生不变”final int num2 = 200;System.out.println(num2); // 200//        num2 = 250; // 错误写法！不能改变！
//        num2 = 200; // 错误写法！// 正确写法！只要保证有唯一一次赋值即可final int num3;num3 = 30;// 对于基本类型来说，不可变说的是变量当中的数据不可改变// 对于引用类型来说，不可变说的是变量当中的地址值不可改变Student stu1 = new Student("赵丽颖");System.out.println(stu1);System.out.println(stu1.getName()); // 赵丽颖stu1 = new Student("霍建华");System.out.println(stu1);System.out.println(stu1.getName()); // 霍建华System.out.println("===============");final Student stu2 = new Student("高圆圆");// 错误写法！final的引用类型变量，其中的地址不可改变
//        stu2 = new Student("赵又廷");System.out.println(stu2.getName()); // 高圆圆stu2.setName("高圆圆圆圆圆圆");System.out.println(stu2.getName()); // 高圆圆圆圆圆圆}}

修饰一个成员变量
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

1… 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2… 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
//如果直接赋值，下面的构造函数和setXxx就都会报错
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;
//    }
}

第二章权限修饰符

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

不同权限的访问能力

可见，public具有最大权限。private则是最小权限。
编写代码时，如果没有特殊的考虑，建议这样使用权限：
成员变量使用 private ，隐藏细节。
构造方法使用 public ，方便创建对象。
成员方法使用 public ，方便调用方法。

情况3

public class MyClass {public int num = 10;public void method() {System.out.println(num);}}``````java
// 导包
import cn.itcast.day11.demo02.MyClass;
public class MySon extends MyClass {public void methodSon() {//     System.out.println(super.num);当 MyClass 中 num 用 default 和 private修饰时报错}
}

情况4

public class MyClass {public int num = 10;public void method() {System.out.println(num);}}``````java
public class Stranger {public void methodStrange() {System.out.println(new MyClass().num);}
}

第三章内部类

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。
例如：心脏只有在身体内才会工作；发动机在汽车内部才会工作

分类：
1… 成员内部类
2… 局部内部类（包含匿名内部类）

成员内部类的定义格式：
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
// …
}
// …
}

注意：内用外，随意访问；外用内，需要内部类对象。

如何使用成员内部类？有两种方式：
1… a.间接方式：在外部类的方法当中，使用内部类；b.然后main只是调用外部类的方法。
2… 直接方式，公式：
类名称对象名 = new 类名称();
【外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();】

成员内部类

public class Body { // 外部类public class Heart { // 成员内部类// 内部类的方法public void beat() {System.out.println("心脏跳动：蹦蹦蹦！");System.out.println("我叫：" + name); // 正确写法！}}// 外部类的成员变量private String name;// 外部类的方法public void methodBody() {System.out.println("外部类的方法");// a.在外部类的方法当中，使用内部类；（匿名对象： new Heart()）new Heart().beat();}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

b. 然后main只是调用外部类的方法。

public class Demo01InnerClass {public static void main(String[] args) {Body body = new Body(); // 外部类的对象// b. 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heartbody.methodBody();System.out.println("=====================");// 成员内部类->直接方式// 按照公式写：Body.Heart heart = new Body().new Heart();heart.beat();}
}

如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

public class Outer {int num = 10; // 外部类的成员变量public class Inner /*extends Object*/ {int num = 20; // 内部类的成员变量public void methodInner() {int num = 30; // 内部类方法的局部变量System.out.println(num); // 局部变量，就近原则System.out.println(this.num); // 内部类的成员变量  System.out.println(Outer.this.num); // 外部类的成员变量}}
}

public class Demo02InnerClass {public static void main(String[] args) {// 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();Outer.Inner obj = new Outer().new Inner();obj.methodInner();}
}

如果一个类是定义在一个***方法内部***的，那么这就是一个局部内部类。(上面的内部类是在方法外面，与方法同级)
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

定义格式：
修饰符 class 外部类名称 {
修饰符返回值类型外部类方法名称(参数列表) {
class 局部内部类名称 {
// …
}
}
}

class Outer {public void methodOuter() {class Inner { // 局部内部类int num = 10;public void methodInner() {System.out.println(num); // 10}}// 出了这个方法外面就不能用Inner inner = new Inner();inner.methodInner();}
}

public class DemoMain {public static void main(String[] args) {Outer obj = new Outer();obj.methodOuter();}
}

小节一下类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：

外部类：public / (default)
成员内部类：public / protected / (default) / private
局部内部类：什么都不能写

局部内部类分所在方法局部变量

public class MyOuter {public void methodOuter() {int num = 10; // 所在方法的局部变量  class MyInner {// 只要局部变量事实不变，那么final关键字可以省略public void methodInner() {System.out.println(num);}}}}

匿名内部类
匿名内部类：是内部类的简化写法。它的本质是一个带具体实现的父类或者父接口的匿名的子类对象。
开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，

定义子类 2. 重写接口中的方法 3. 创建子类对象 4. 调用重写后的方法
我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。
减少了创建MyInterfaceImpl文件和实现类对象

匿名内部类的定义格式：
接口名称对象名 = new 接口名称() {
// 覆盖重写所有抽象方法
};

对格式“new 接口名称() {…}”进行解析：
1… new代表创建对象的动作
2… 接口名称就是匿名内部类需要实现哪个接口
3… {…}这才是匿名内部类的内容

另外还要注意几点问题：
1… 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
2… 匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。(就只能使用xxxImpl 实现类)
3… 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！

public interface MyInterface {void method1(); // 抽象方法  省去前面两个修饰符void method2();
}

public class MyInterfaceImpl implements MyInterface {@Overridepublic void method1() {System.out.println("实现类覆盖重写了方法！111");}@Overridepublic void method2() {System.out.println("实现类覆盖重写了方法！222");}
}

public class DemoMain {public static void main(String[] args) {//        MyInterface obj = new MyInterfaceImpl();  多态写法
//        obj.method();//        MyInterface some = new MyInterface(); // 错误写法！// 使用匿名内部类，但不是匿名对象（区别上面的实现类对象），对象名称就叫objAMyInterface objA = new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-A");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-A");}};objA.method1();objA.method2();System.out.println("=================");// 使用了匿名内部类，而且省略了对象名称，也是匿名对象new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-B");}}.method1();// 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-B");}}.method2();}}

使用类作为类的成员变量类型
实际上 String 也是一个类

public class Hero {private String name; // 英雄的名字private int age; // 英雄的年龄private Weapon weapon; // 英雄的武器public void attack() {System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方。");}//...省略构造函数
}

public class Weapon {private String code; // 武器的代号//...省略构造函数
}

public class DemoMain {public static void main(String[] args) {// 创建一个英雄角色Hero hero = new Hero();// 为英雄起一个名字，并且设置年龄hero.setName("盖伦");hero.setAge(20);// 创建一个武器对象Weapon weapon = new Weapon("AK-47");// 为英雄配备武器hero.setWeapon(weapon);// 年龄为20的盖伦用多兰剑攻击敌方。hero.attack();}
}

使用接口作为类的成员变量类型

public interface Skill {void use(); // 释放技能的抽象方法   省略修饰符
}

public class SkillImpl implements Skill {@Overridepublic void use() {System.out.println("Biu~biu~biu~");}
}

public class Hero {private String name; // 英雄的名称private Skill skill; // 英雄的技能public void attack() {System.out.println("我叫" + name + "，开始施放技能：");skill.use(); // 调用接口中的抽象方法System.out.println("施放技能完成。");}//...省略构造函数
}

public class DemoGame {public static void main(String[] args) {Hero hero = new Hero();hero.setName("艾希"); // 设置英雄的名称// 设置英雄技能
//        hero.setSkill(new SkillImpl()); // 使用单独定义的实现类// 还可以改成使用匿名内部类
//        Skill skill = new Skill() {//            @Override
//            public void use() {//                System.out.println("Pia~pia~pia~");
//            }
//        };
//        hero.setSkill(skill);// 进一步简化，同时使用匿名内部类和匿名对象hero.setSkill(new Skill() {@Overridepublic void use() {System.out.println("Biu~Pia~Biu~Pia~");}});hero.attack();}}

使用接口作为方法的参数和返回值
java.util.List正是ArrayList所实现的接口。

public class DemoInterface {public static void main(String[] args) {// 左边是接口名称，右边是实现类名称，这就是多态写法List<String> list = new ArrayList<>();List<String> result = addNames(list);for (int i = 0; i < result.size(); i++) {System.out.println(result.get(i));}}public static List<String> addNames(List<String> list) {list.add("迪丽热巴");list.add("古力娜扎");list.add("玛尔扎哈");list.add("沙扬娜拉");return list;}
}

红包案例