java学习10

final关键字

final关键字代表最终的、不可变的。

常见的四种用法：

1.可以用来修饰一个类。
2.可以用来修饰一个方法。
3.可以用来修饰一个局部变量。
4.可以用来形容一个成员变量。

final关键字用于修饰类

public final class 类名称{
	//...
}

【当前类不能有任何子类】

注意：
如果一个类是final的，那么其中所有的成员方法都无法进行覆盖重写（因为无子类）

final关键字用于修饰成员方法

当final关键字用来修饰方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。

修饰符 final 返回值类型 方法名称(参数列表){
	方法体
}

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

final关键字用于修饰局部变量

一旦使用final关键字修饰局部变量，那么这个变量就不能进行更改。【一次赋值，终生不变】

对于基本类型来说，不可变说的是变量当中的数据不可变。

对于引用类型来说，不可变说的是变量当中的地址值不可改变。

final关键字用于修饰成员变量

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

1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。
3.必须保证类当中所有的重载的构造方法，都最终会对final的成员变量进行赋值。

四种权限修饰符

	public > protected > (default) > private
同一个类	Y > Y > Y > Y
同一个包	Y > Y > Y > N
不同包子类	Y > Y > N > N
不同包非子类	Y > N > N > N

内部类的概念与分类

一个类的内部包含另一个类

分类：

1.成员内部类
2.局部内部类（包含匿名内部类）

成员内部类

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

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

成员内部类的使用

1.间接方式：在外部类的方法当中，使用内部类。main只是调用外部类的方法。
2.直接方式：
	外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

内部类的同名变量访问

【在内部类使用外部类成员变量】
外部类名称.this.外部类成员变量名

局部内部类

如果一个类是定义在方法内部的，那么这就是一个局部内部类。

局部：只有当前所属的方法才能使用它，出了这个方法外面就不能使用。

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

public class DemoMain {

	public static void main(String[] args) {
		
		Outer outer = new Outer();
		outer.methodOuter();//10
		
	}
	
}

public class Outer {
	
	public void methodOuter() {
		class Inner{
			int num = 10;
			public void methodInner() {
				System.out.println(num);
			}
		}
		Inner inner = new Inner();
		inner.methodInner();
	}

}

局部内部类的final问题

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

【从Java 8+ 开始，只要局部变量事实不变，那么final关键字可省略。】
原因：

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

匿名内部类

如果接口的实现类（或者父类的子类）只需要使用唯一的一次。那么这种情况下就可以省略掉该类的定义，而改为使用匿名内部类。

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

public class DemoMain1 {
	
	public static void main(String[] args) {
		
		MyInterface obj = new MyInterface() {
			
			@Override
			public void method() {
				// TODO Auto-generated method stub
				System.out.println("匿名内部类重写了抽象方法");
			}
		};
		
		obj.method();//匿名内部类重写了抽象方法
		
	}

}

public interface MyInterface {
	
	public abstract void method();

}

【对格式"new 接口名称() {…}"进行解析】

1.new代表创建对象的动作。
2.接口名称就是匿名内部类需要实现哪个接口。
3.{...}是匿名内部类的内容。

注意：

1.匿名内部类，在创建对象的时候，只能使用一次。
2.匿名对象，在调用方法的时候，只能调用一次。
3.匿名内部类是省略了【实现类/子类名称】，但匿名对象是省略了【对象名称】

类作为成员变量类型

public class DemoMain {
	
	public static void main (String[] args) {
		//创建一个英雄
		Hero hero = new Hero();
		
		hero.setName("花木兰");
		hero.setAge(18);
		
		Weapon weapon = new Weapon("重剑");
		
		hero.setWeapon(weapon);
		
		hero.attack();//18岁的花木兰正在使用重剑
		
	}

}

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 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 DemoMain {
	
	public static void main(String[] args) {
		
		//创建一名英雄
		Hero hero = new Hero();
		
		hero.setName("艾希");
		
		//使用单独定义的实现类
//		hero.setSkill(new SkillImpl());
		
		//使用匿名内部类
//		Skill skill = new Skill() {
//			
//			@Override
//			public void useSkill() {
//				// TODO Auto-generated method stub
//				System.out.println("技能2");
//			}
//		};
//		hero.setSkill(skill);		
		
		//同时使用 匿名对象 匿名内部类
		hero.setSkill(new Skill() {
			
			@Override
			public void useSkill() {
				// TODO Auto-generated method stub
				System.out.println("技能3");
			}
		});

		
		hero.attack();
		
		
	}

}

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.useSkill();
	}
	
	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 interface Skill {
	
	public abstract void useSkill();

}

public class SkillImpl implements Skill{

	@Override
	public void useSkill() {
		// TODO Auto-generated method stub
		System.out.println("技能1");
	}

}

接口作为方法的参数或返回值

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

public class pracctice {
	
	public static void main(String[] args) {
		//左边是接口名称 右边是实现类名称 这是多态写法
		List<String> list = new ArrayList<String>();
		
		List<String> result = addName(list);
		for(int i = 0; i < list.size(); i++) {
			System.out.println(result.get(i));
		}
		
	}
	
	public static List<String> addName(List<String> list){
		list.add("周老大");
		list.add("周老二");
		list.add("周老三");
		return list;
		
	}

}

类的权限修饰符

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

1.外部类：public/(default)
2.成员内部类：public/protected/(default)/private
3.局部内部类：什么都不可以写