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

学习目标：

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

---

学习内容：

final关键字

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

//修饰类
final class ClassName{

}

//修饰方法
public final void MethodName(){
	//方法体
}

//修饰变量
public final String name = "张三";

局部变量----引用类型

被final修饰，只能指向一个对象，地址不能再修改，但不影响成员变量setter方法修改值

final User u = new User();
u = new User();	 //编译失败，地址值无法改变	
u.setName("张三");//编译成功

成员变量

成员变量被final修饰，只能通过2个方法赋值

定义成员变量赋初值
构造方法初始化，必须保证每个构造方法都要有给final修饰变量赋初值的语句，同时setter方法将不再起作用，并报错，需要删除

public class ClassName{
	final String name = "张三";//final修饰的变量不能再被更改值
}

public class ClassName{
	final String name;
	public ClassName(){
		this.name = name;
	}
	public ClassName(String name){
		this.name = name;
	}
}

权限修饰符

使用不同的权限修饰符，能够修改访问权限

• public 公共的
• protected 受保护的
• default 默认的
• private 私有的

不同权限的访问能力

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

定义在类当中，方法外

class ClassName{
	class InnerClassName{
	}
	public void method(){
	//方法体
	}
}

访问特点

内部类可以随意访问外部类的所有变量和方法
外部类访问内部类需要new创建内部类对象

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

Animal.Cat obj = new Animal().new Cat();

匿名内部类

当接口/父类只需要声明一次，后续不会再次用得到，可以使用匿名内部类，可以避免创建新的接口实现类/子类，也不需要实现类名
匿名内部类必须继承一个父类或者实现一个父接口

public interface InterfaceDemo {
    public abstract void method1();
}

public class InterfaceClass {
    public static void main(String[] args) {
        //密名内部类,避免不得不创建一个实现类
        InterfaceDemo inter = new InterfaceDemo() {
            @Override
            public void method1() {
                System.out.println("重写方法一");
            }
        };
        inter.method1();
    }
}

class作为成员变量

String 其实也是一个类，成员变量可以是Java自带包的类，也可以是自定义的类

public class Weapon {
    private String name;//武器

    public String getName() {
        return name;
    }

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

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

    public Weapon() {
    }
}

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

    public void attack() {
        System.out.println("英雄" + this.name + "使用" + this.weapon.getName()+"攻击");
    }

    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 Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }

    public Hero() {
    }
}

public class GameStart {
    public static void main(String[] args) {
        Hero hero = new Hero();
        Weapon weapon = new Weapon("无敌大鲨鱼");
        hero.setName("鲁班");
        hero.setWeapon(weapon);
        hero.attack();
    }
}

interface作为成员变量

package April.Apr8thpm;

public interface InterfaceAttack {
    public abstract void BBB();
}

package April.Apr8thpm;

public class InterfaceDemo {
    private String name;
    private InterfaceAttack interfaceAttack;

    public void attack(){
        System.out.println("英雄"+this.name);
        //实现接口类调用主要方法
        interfaceAttack.BBB();
    }
    public String getName() {
        return name;
    }

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

    public InterfaceAttack getAaa() {
        return interfaceAttack;
    }
	//此方法Aaa()仅为传入一个接口的实现类
    public void setAaa(InterfaceAttack interfaceAttack) {
        this.interfaceAttack = interfaceAttack;
    }

    public InterfaceDemo() {
    }

    public InterfaceDemo(String name, InterfaceAttack interfaceAttack) {
        this.name = name;
        this.interfaceAttack = interfaceAttack;
    }
}

package April.Apr8thpm;

public class InterfaceStart {
    public static void main(String[] args) {
        InterfaceDemo interfaceDemo = new InterfaceDemo();
        interfaceDemo.setName("鲁班");
        InterfaceAttack interfaceAttack = new InterfaceAttack() {
            @Override
            //此方法为重写接口，以便传入接口实现类能够调用执行功能
            public void BBB() {
                System.out.println("Biu biu biu");
            }
        };
        //此方法Aaa()仅为传入一个接口的实现类
        interfaceDemo.setAaa(interfaceAttack);
        interfaceDemo.attack();
    }
}

接口类型也可以作为方法的返回类型和返回值，Arraylist <泛型> 其实是接口List<泛型>的实现类，由于Java中有多态的概念，实现类Arraylist可以当作返回值或返回类型，则其接口/父类List<泛型>，也可以当作返回值类型/返回值

---