面向对象之权限、内部类_Java12

01_四种权限修饰符

-	本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

• 例：（举例说明protected不同包下子类可以访问）

//创建了Person类
package com.baidu;
public class Person {
	private String name;
	private int age;

	public Person(){}
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}

	public String getName(){
		return name;
	}

	public int getAge(){
		return age;
	}
	
	protected void print(){  //protected 权限
		System.out.println("print");
	}
}

• 创建了 Person的子类Student（不同包下的子类）

//创建了 Person的子类Student
package com.xxx;
import com.baidu.Person;
public class Student extends Person {
	
	public Student(){}
	
	public Student(String name, int age){
		super(name, age);
	}

	public void method(){
		print();
	}
}

• 主函数 访问两个包

package com.heima;
import com.xxx.Student;
//import com.baidu.Person; //可以不导入父类Person，因为子类中已经导入
class Demo1_Package {
	public static void main(String[] args) {
		Student s = new Student("张三", 23);
		System.out.println(s.getName()+"..."+s.getAge());
		s.method();
	}
}

• 执行通过，说明protected不同包下子类可以访问
  

02_内部类

• A：内部类概述
• B：内部类访问特点
  • a：内部类可以直接访问外部类的成员，包括私有
  • b：外部类要访问内部类的成员，必须创建对象
  • 外部类名.内部类名 对象名 = 外部类对象.内部类对象

• 示例（创建内部类）

class Demo1_InnerClass {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.method();
	}
}

class Outer {
	private int num = 10;
	class Inner {
		public void method(){
			System.out.println(num);
		}
	}
}
//10

• 示例（私有内部类的访问）

class Demo2_InnerClass {
	public static void main(String[] args) {
		//不能创建对象，因为类被私有了
		//Outer.Inner oi = new Outer().new Inner();
		//oi.method();

		Outer o = new Outer();
		o.print();
	}
}

class Outer {
	private int num = 20;
	private class Inner {
		public void method(){
			System.out.println(num);
		}
	}
	/*
	因为内部类被私有了，所以不能创建对象
	就在本类中提供方法，本类可以访问私有成员
	*/
	public void print(){
		Inner i = new Inner();
		i.method();
	}
}
//20

• 示例（静态成员内部类）

class Demo3_InnerClass {
	public static void main(String[] args) {
		//外部类名.内部类名	对象名 = 外部类名.内部类对象
		Outer.Inner oi = new Outer.Inner();
		oi.method();
		
		//类名调用
		Outer.Inner2.print();
	}
}
class Outer {
	static class Inner {
		public void method(){
			System.out.println("method");
		}
	}

	static class Inner2 {
		public static void print(){
			System.out.println("print");
		}
	}
}
//method
//print

• 示例：练习

//要求：使用已知变量，在控制台输出30，20，10
class Test1_InnerClass {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

class Outer {
	public int num = 10;
	
	class Inner {
		public int num = 20;
		public void show(){
			int num = 30;
			System.out.println(??);
			System.out.println(??);
			System.out.println(??);
		}
	}
}

//要求：使用已知变量，在控制台输出30，20，10
class Test1_InnerClass {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

class Outer {
	public int num = 10;
	
	class Inner {
		public int num = 20;
		public void show(){
			int num = 30;
			System.out.println(num);
			System.out.println(new Outer().new Inner().num);
			System.out.println(new Outer().num);
		}
	}
}

//要求：使用已知变量，在控制台输出30，20，10
class Test1_InnerClass {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

class Outer {
	public int num = 10;
	
	class Inner {
		public int num = 20;
		public void show(){
			int num = 30;
			System.out.println(num);
			System.out.println(this.num);
			System.out.println(Outer.this.num);
		}
	}
}

03_局部内部类访问局部变量

• 局部内部类访问局部变量必须用final修饰
• 为什么局部内部类在访问他所在方法中的局部变量必须用final修饰
  • 因为当调用这个方法时，局部变量如果没有用final修饰，他的生命周期和方法的生命周期是一样的，当方法弹栈时，这个局部变量也会消失。
  • 但是jdk1.8取消了

• 示例

class Demo4_InnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

//局部内部类
class Outer {
	public void method(){
		class Inner {
			public void print(){
				System.out.println("print");
			}
		}

		Inner i = new Inner();
		i.print();
	}
	
	/*错误的，局部内部类，只能在其所在的方法中访问
	public void run(){
		Inner i = new Inner();
		i.print();
	}
	*/
}

04_匿名内部类

• A：匿名内部类
  • 就是内部类的简化写法
• B：前提：存在一个类或者接口
  • 这里的类可以是具体类，也可以时抽象类
• C：格式
  • new 类名或者接口名(){
    重写方法; }
• D：本质是什么呢？
  • 其实就是一个继承了该类或者实现了该接口的子类匿名对象

• 示例 （匿名内部类）*****

class Demo1_NoNameInnerClass {
	public static void main(String[] args) {
		Out.In oi = new Out().new In();
		oi.print();

		Out o = new Out();
		o.method();

	}
}

interface Inter {
	public abstract void print();
}

class Out {
	class In implements Inter{
		public void print(){
			System.out.println("print");
		}
	}

	public void method(){
		//实现Inter对象(匿名对象)，并重写
		new Inter(){								//new Inter(); 实现Inter接口
			public void print(){
				System.out.println("print222");		//重写抽象方法
			}
		}.print();									//最后调用print方法
	}
}

//print
//print222

• 示例 （匿名内部类重写多个方法调用）*****

class Demo2_NoNameInnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

interface Inter {
	public abstract void show1();
	public abstract void show2();
}

class Outer {
	public void method(){
		Inter i = new Inter(){			//父类引用指向子类对象
			public void show1(){
				System.out.println("show1");
			}
			public void show2(){
				System.out.println("show2");
			}
		};

		i.show1();
		i.show2();
	}
}

• 练习 （匿名内部，要求补齐代码）

//按照要求补齐代码，要求在控制台输出"Hello World!"
class Test2_NoNameInnerClass {
	public static void main(String[] args) {
		Outer.method().show();
	}
}
interface Inter {
	void show();
}
class Outer {
	//补齐代码
}

//按照要求补齐代码，要求在控制台输出"Hello World!"
class Test2_NoNameInnerClass {
	public static void main(String[] args) {
		//Outer.method().show();
		Outer.method().show();
		
		/*
		//Outer.method().show() 拆分
		Inter i = Outer.method();
		i.show();
		*/
	}
}

interface Inter {
	public abstract void show();
}

class Outer {
	//Outer.method(),类名.方法，说明该方法是静态的
	//Outer.method().show(), 可以看做是 类.show(), 所以 Outer.method()返回的是一个类，Inter的子类
	public static Inter method(){
		return new Inter(){				//表示返回Inter子类对象
			public void show(){
				System.out.println("Hello World!");
			}
		};
	}
}