Java-final、权限、内部类-第11节

学习目标：

学会使用final关键字；
了解权限修饰符；
学会使用内部类。

---

学习内容：

一、final关键字

1、修饰类

• 修饰的类不能有任何子类，即太监类
• final修饰的类中的抽象方法不能被重写

2、修饰方法

• 修饰的方法不能被覆盖重写
• abstract和final关键字冲突，不能同时存在

3、修饰局部变量

• 修饰的局部变量不能进行更改，只能赋值一次
• final修饰变量不可变：
  • 基本类型变量的数据不可以变
  • 引用类型变量的地址不可变

4、修饰成员变量

• 由于成员变量具有默认值，所以用final进行修饰必须要进行赋值
• 对成员变量赋值，可以在直接赋值与通过构造方法赋值两种方法中选一个
• 通过构造方法进行赋值时，必须保证所有的构造方法都要进行赋值

二、权限修饰符

				public====>protected====>(default)====>private
	同一个类		yes			yes				yes			yes
	同一个包		yes			yes				yes			no
	不同包子类		yes			yes				no			no
	不同包非子类	yes			no				no			no

三、内部类

1、成员内部类

• 定义

	修饰符 class 外部类名称{
		修饰符 class 内部类名称{
			// ...;
		}
		// ...;
	}

• 注意
  内部类访问外部类随意，外部类访问内部类，需要内部类对象
• 使用
  • 间接使用：在外部类的方法中，使用内部类，main只是调用外部类
  • 直接方式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
  • 在内部类的成员方法中使用外部类的成员变量
    外部类名称.this.成员变量名

2、局部内部类（类定义在一个方法中，方法外面不能用）

• 定义

			修饰符 class 外部类名称{
				修饰符 返回值类型 外部类方法名称（参数列表）{
					修饰符 class 内部类名称{
						// ...;
					}
				}
			}

• 使用
  • 如果局部内部类要访问所在方法的局部变量，该局部变量需要final修饰，如果局部变量没有变化，final关键字可以省略（从Java8开始）；
  • 原因：局部变量存放在栈内存，局部内部类存放在堆内存，方法执行结束栈内存会释放，而堆内存会等垃圾清理才释放，即局部变量生命周期<局部内部类生命周期，final之后的局部变量可以将数据复制一份给局部内部类。

3、匿名内部类

• 背景
  如果接口的实现类（父类的子类）只需使用一次，可以省略实现类（子类）的定义，改成【匿名内部类】
• 定义格式

	接口名称 对象名 = new 接口名称（）{
		// 覆盖重写所有的抽象方法;
	};

• 注意

  • 匿名内部类是{}中的内容；
  • 在创建对象时，只能使用唯一的一次；

• PS:定义一个类的时候，权限修饰符规则

  • 外部类：public/(default)
  • 成员内部类：四种都可以
  • 局部内部类：什么都不写

---

学习产出：

1、 final关键字

package mypackage.day07.demo01;

public abstract class DemoParent {
    public abstract void func();

    public final void func1(){
        System.out.println("final修饰的方法");
    }
}

package mypackage.day07.demo01;
// final修饰类
public final class DemoFinalClass extends DemoParent{
    @Override
    public void func() {
        System.out.println("final类中重写父类方法！！！");
    }
    // final 修饰的类中不可以有抽象方法
    // public abstract void func1();

    // ===============================================
    // final修饰方法，不能被重写
    // @Override
    // public void func1(){
    //     System.out.println("重写final修饰的方法！！！");
    // }

    // =======================================================
    // final修饰局部变量
    public void func2(){
        final int num = 2;
        final int num1;
        num1 = 3;
        // final修饰的局部变量只能被赋值一次
        // num1 = 1;
    }

    // ======================================================
    // final修饰成员变量
    final int num1 = 10;
    final int num2;

    public DemoFinalClass(int num2) {
        this.num2 = num2;
        num2 = 20;
    }

    public DemoFinalClass() {
        num2 = 20;
    }
}

package mypackage.day07.demo01;

public class DemoFinal {
    public static void main(String[] args) {
        DemoFinalClass demoFinalClass = new DemoFinalClass();
        demoFinalClass.func();
    }
}

2、内部类

package mypackage.day07.demo02;

public class OuterClass {
    public class InnerClass {
        private int num = 2;

        public void func2() {
            System.out.println("内部类方法！！！");
            System.out.println("我叫：" + Name);
        }

        public void func3() {
            int num = 3;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(OuterClass.this.num);
        }

        public void func4() {
            class Inner{
                int num0 = 1000;

                public int getNum0() {
                    return num0;
                }

                public void setNum0(int num0) {
                    this.num0 = num0;
                }

                public Inner(int num0) {

                    this.num0 = num0;
                }
            }

            System.out.println("局部内部类输出："+new Inner(1000).getNum0());
        }
    }

    private int num = 1;
    private String Name;

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public void func1() {
        System.out.println("外部类方法！！！");
        new InnerClass().func2();
    }
}

package mypackage.day07.demo02;

public class DemoInnerClass {
    public static void main(String[] args) {
        System.out.println("============间接使用=============");
        OuterClass outerClass = new OuterClass();
        outerClass.func1();
        System.out.println("============直接使用=============");
        OuterClass.InnerClass obj = new OuterClass().new InnerClass();
        obj.func2();
        System.out.println("============内部类方法中访问外部类成员变量===========");
        obj.func3();
        System.out.println("============局部内部类的使用===========");
        obj.func4();
    }
}

3、 匿名内部类

package mypackage.day07.demo03;

public interface Interface {
    public abstract void func();
}

package mypackage.day07.demo03;

public class DemoNoname {
    public static void main(String[] args) {
        Interface anInterface = new Interface(){

            @Override
            public void func() {
                System.out.println("覆盖重写抽象函数！！！");
            }
        };
        anInterface.func();
    }

}

4、游戏案例一

package mypackage.day07.demo04;

public class Hero {
    private String name;
    private int age;
    private Weapon weapon;

    public void attack() {
        System.out.println(age+"岁的"+name+"手执"+weapon.getCode()+"攻击敌人！！！");
    }

    public Hero() {
    }

    public Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }

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

package mypackage.day07.demo04;

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

package mypackage.day07.demo04;

public class Soul {
    public static void main(String[] args) {
        Weapon weapon = new Weapon("多兰剑");
        Hero hero = new Hero("Jim", 24, weapon);
        hero.attack();
    }
}

5、游戏案例二

package mypackage.day07.demo05;

public class Hero {
    private String name;
    private int age;
    private Skill skill;

    public void Attack() {
        System.out.println(name+"准备释放技能~~~");
        skill.use();
        System.out.println("释放技能完毕！！！");
    }

    public Hero() {
    }

    public Hero(String name, int age, Skill skill) {
        this.name = name;
        this.age = age;
        this.skill = skill;
    }

    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 Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}

package mypackage.day07.demo05;

public interface Skill {
    void use();
}

package mypackage.day07.demo05;

public class SkillAchieve implements Skill {

    @Override
    public void use() {
        System.out.println("Biu~biu~biu~~~");
    }
}

package mypackage.day07.demo05;

public class Main {
    public static void main(String[] args) {
        /*
        SkillAchieve skill = new SkillAchieve();
        Hero hero = new Hero("Tom", 23, skill);
        hero.Attack();
        */

        Hero hero = new Hero();
        hero.setName("Mary");
        hero.setAge(18);
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Pia~pia~pia~~~");
            }
        });
        hero.Attack();
    }
}

6、接口参数

package mypackage.day07.demo06;

import java.util.ArrayList;
import java.util.List;

public class DemoInterfacePara {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        List<Integer> l = addName(list);
        for (int i = 0; i < l.size(); i++) {
            System.out.println(l.get(i));
        }
    }

    public static List<Integer> addName(List<Integer> list) {
        list.add(1);
        list.add(2);
        list.add(3);
        return list;
    }
}