一:final关键字、权限、内部类

1.final 概述

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

2.final使用方法

final 不可改变的,用来修饰类、方法、变量
- 类:被修饰的类,不能被继承.
- 方法 : 被修饰的方法,不能被重写.
- 变量:被修饰的变量,不能被重新赋值.
使用方法:
- 格式:
```
final class 类名{}
```
- 我们以前学习过的常用类中,有很多都是给我们直接使用的,不可被外界修改的类,都是被final修饰的.
  - public final class String
  - public final class Math
  - public final class Scanner 等
- final 修饰方法
  - 当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
  - 格式
```
格式：
修饰符 final 返回值类型 方法名称(参数列表) {// 方法体
}
```
  - 被final修饰的方法不可被重写,重写发生在继承或者接口,就是为了扩展功能,而final定义的是不可变的,因此要切记: final 和abstract 不可同时使用.
  - 注意事项：
    对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
- final修饰变量
  对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
  1. 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
  2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
  3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

二:权限

四种权限修饰符

Java中有四种权限修饰符：
public > protected > (default) > private
同一个类（我自己） YES YES YES YES
同一个包（我邻居） YES YES YES NO
不同包子类（我儿子） YES YES NO NO
不同包非子类（陌生人） YES NO NO NO

注意事项：(default)并不是关键字“default”，而是根本不写。

三:内部类

1.内部类的概念

如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。

例如：身体和心脏的关系。又如：汽车和发动机的关系。

2.内部类的分类

成员内部类
局部内部类[包含匿名内部类]

3.成员内部类

成员内部类的定义格式
```
修饰符 class 外部类名称 {修饰符 class 内部类名称 {// ...}// ...
}
```
注意 :内用外,随便用,外用内,需要内部类对象.
如何使用成员内部类？有两种方式：
1. 间接方式：在外部类的方法当中，使用内部类；然后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("外部类的方法");new Heart().beat();}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

测试类

public class Demo01InnerClass {public static void main(String[] args) {//先创建一个外部类对象Body body = new Body();/* public void methodBody() {System.out.println("外部类的方法");new Heart().beat();}*///通过调用外部类的方法来访问内部类的方法body.methodBody();System.out.println("=======");//【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】Body.Heart heart = new Body().new Heart();heart.beat();}
}

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

// 如果出现了重名现象，那么格式是：外部类名称.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();}}

4.局部内部类(包含匿名内部类)

概念:

听到这个概念,顾名思义,就是在外部类的方法里定义了内部类.该内部类仅仅属于这个方法,出了这个方法以外的,就访问不到了.

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
```
定义格式：
修饰符 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();}}

小小总结:
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。

备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。

原因：
1. new出来的对象在堆内存当中。
2. 局部变量是跟着方法走的，在栈内存当中。
3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4. 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

5.匿名内部类[用的最多]

先举个例子[正常的接口使用步骤]

定义接口
创建接口的实现类,重写接口里的所有抽象方法

实现类.方法名调用.

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");}
}

 //通过多态的写法来调用方法MyInterface obj = new MyInterfaceImpl();obj.method();

使用匿名内部类的做法

定义接口,创建抽象方法
创建一个测试类,直接在main 方法通过匿名内部类的指定格式 new 接口 ,调用方法执行

匿名内部类的格式: 不要忘记分号

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

代码展示

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");}};}}

使用匿名内部类的注意事项
- 格式解析
  对格式“new 接口名称() {…}”进行解析：
  1. new代表创建对象的动作
  2. 接口名称就是匿名内部类需要实现哪个接口
  3. {…}这才是匿名内部类的内容
- 注意问题
  - 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
    如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
  - 匿名对象，在【调用方法】的时候，只能调用唯一一次。
    如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
  - 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
- 强调：匿名内部类和匿名对象不是一回事！！！
  - 匿名内部类:省略了接口的是实现类的书写,直接通过特殊的new接口来创建接口的实现类,并用匿名内部类的名字作为对象名,对方法进行调用.
  - 匿名对象,判断这个对象仅仅会使用一次,不需要给这个对象一个名字,用完了就找不到了.
使用匿名对象调用方法
1. 使用了匿名内部类，而且省略了对象名称，也是匿名对象
2. 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
3. 若要重复使用,则不能用匿名的东西.
```
  new MyInterface() {@Overridepublic void method1() {System.out.println("匿名内部类实现了方法！111-B");}@Overridepublic void method2() {System.out.println("匿名内部类实现了方法！222-B");}}.method1();
```

6.类作为成员变量类型

知识回顾

定义一个类所需要的那些东西呢?
- 类要成员变量和成员方法
- 成员变量可不可以用一个类作为他的成员变量呢 .答案是肯定的.下面我们来模拟一下.

模仿英雄联盟的角色和装备来看,一个英雄,要有名字,要有方法,还要有装备,那么装备也要有名字,装备也要有他自己的功能提供给英雄使用.

定义一个武器类

public class Weapon {private String code; // 武器的代号public Weapon() {}public Weapon(String code) {this.code = code;}public String getCode() {return code;}public void setCode(String code) {this.code = code;}
}

定义英雄类

// 游戏当中的英雄角色类
public class Hero {private String name; // 英雄的名字private int age; // 英雄的年龄private Weapon weapon; // 定义一个武器类作为我的一个属性.public Hero() {}public Hero(String name, int age, Weapon weapon) {this.name = name;this.age = age;this.weapon = weapon;}public void attack() {System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方。");}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Weapon getWeapon() {return weapon;}public void setWeapon(Weapon weapon) {this.weapon = weapon;}
}

定义一个测试类

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();}}

同理 ,引用类型均可以作为一个类的成员变量.

7.接口作为成员变量类型

定义一个普通的英雄类,英雄的成员变量需要要给技能的接口.具体的实现看下面的代码.

定义一个技能接口.

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 Hero() {}public Hero(String name, Skill skill) {this.name = name;this.skill = skill;}public void attack() {System.out.println("我叫" + name + "，开始施放技能：");skill.use(); // 调用接口中的抽象方法System.out.println("施放技能完成。");}public String getName() {return name;}public void setName(String name) {this.name = name;}public Skill getSkill() {return skill;}public void setSkill(Skill skill) {this.skill = skill;}
}

定义一个测试类.

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();}}

8.接口作为方法的参数和方法的返回值

定义一个方法,传入参数为一个空集合,返回一个装满东西的集合.

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;}}

final关键字、权限、内部类相关推荐

Java学习笔记⑩（final关键字、内部类）
一.final关键字 final关键字代表最终.不可改变的. 常用的四种方法: 可以用来修饰一个类可以用来修饰一个方法还可以用来修饰一个局部变量还可以用来修饰一个成员变量不能使用一个final ...
java中final关键字、权限修饰符、内部类（成员内部类、局部内部类、匿名内部类）
final关键字: final表示最终的不可变的,在java中可以用来修饰类或方法.局部变量.成员变量. // 1.final关键字修饰类需要放在class关键字前面,表示不可变的类,需要注意,这里表 ...
java——final关键字、权限、内部类、引用类型
final关键字代表最终.不可改变的.常见四种用法: 1. 可以用来修饰一个类 2. 可以用来修饰一个方法 3. 还可以用来修饰一个局部变量 4. 还可以用来修饰一个成员变量当final关键字用来修 ...
final关键字概念及其四种用法、四种权限修饰符的优先级以及内部类的相关概念
一.final关键字代表最终.不可改变的. 常见的四种用法: ①.可以用来修饰一个类. ②.可以用来修饰一个方法. ③.还可以用来修饰一个局部变量. ④.还可以用来修饰一个成员变量. (1).修饰一个 ...
Java_Day10 final关键字、权限修饰符、内部类
final关键字代表最终.不可改变的常见四种用法: 可以用来修饰一个类不能使用一个final类来作为父类格式: public final class 类名称{}//当前这个类不能有任何的子类 ...
Java中final关键字、权限、内部类
一:final关键字学习了继承后,我们知道,子类可以在父类的基础上改写父类内容,比如,方法重写.那么我们能不能随意的继承API中提供的类,改写其内容呢?显然这是不合适的.为了避免这种随意改写的情况, ...
java内部类的权限符,static介绍、内部类、final、权限修饰符的作用范围，
static介绍.内部类.final.权限修饰符的作用范围,static 关键字:(可用于修饰方法.变量) static 特点: static是静态修饰符,一般修饰成员变量.被static修饰的属于全 ...
JavaSE——面向对象高级（继承、final关键字、抽象类与接口、多态、Object类、内部类、包装类、可变参数）
第3节面向对象高级一.继承 1.1 概述和使用继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类.继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法 ...
JAVA day07 权限，封装，JavaBean（规范代码），static、final关键字
1.权限在Java中提供了四种访问权限,使⽤不同的访问权限修饰符修饰时,被修饰的内容会有不同的访问权限: public:公共的 protected:受保护的 default(friendly):默认 ...

final关键字、权限、内部类