Java学习 ---- 匿名内部类

Day10.01_____Java中的包

• 为什么要有包？
  • 将项目中前端、后台、数据库的代码分离开来。包就相当于我们平时所用的文件夹。当我们给一个类设置了包以后，当有子类想要继承时，必须要导包
• 创建的格式是什么：
  • package 包名
    • 其中包名是由很多层级关系，例子：
      • package cn.bean的文件夹形成时，层级与层级之间用符号" . "隔开，并且包名全部用小写
• 创建包的注意事项 ：
  • (1) 包必须下载代码的第一行
  • (2) 每个类中只能定义一个包
  • (3) 如果一个父类和子类在不同的包中，父类的类必须是public修饰的，成员方法也必须是public修饰的
• 包的导入格式：
  • import 包名；
    • 例子： import cn.bean
• 包导入的注意事项：
  • (1) 导入包写在创建包的下一行
  • (2) 每个类可以导入多个包
    
    
    

Day10.02_____四种权限修饰符

• 访问情况（Y表示可以访问）
                 本类      同一包下(子类和无关类)      不同包下(子类)       不同包下(无关类)
  private       Y
  默认           Y                      Y
  protected   Y                      Y                                      Y
  public         Y                     Y                                      Y                            Y
  
  
  

Day10.03_____类、成员方法、成员变量、构造方法使用修饰符规则

• 权限修饰符
  • private
  • 默认
  • protected
  • public
• 状态修饰符
  • final
  • static
• 抽象修饰符： abstract
• 类： 常用public修饰
• 成员方法： 常用public修饰，但当类中的所有方法都为static修饰时，需要用private修饰构造方法
• 成员变量： 常用private修饰，修饰完后在类中提供setXxx( )和getXxx( )方法
• 构造方法： 常用public修饰
  
  
  

Day10.04_____成员内部类

• 成员内部类是什么？
  • 在类中定义的类
• 外部类如何访问默认权限下成员内部类的成员 ?
  • 解析： Outer.Inner是对内部类引用的一个所属解释，表示这个内部类Inner是外部类Outer的成员内部类。这样表示是为了避免二义性，假设在另一个类Outer2中还有一个内部类，名字也为Inner，如果在创建内部类对象的时候直接写Inner，Java虚拟机会分不清是哪个类中的Inner；new Outer().new Inner()是对对象的创建，为什么前面有new Outer()，是因为我们把Inner看作是该类的一个成员，而我们在普通类中调用成员的方法为创建该类的对象，通过( 对象. )的方式进行访问，因此前面一步是在创建外部类的对象，那为什么后面又有new Inner()，因为外部访问的成员不是方法，也不是属性而是一个类，而我们想要创建的是内部类的对象，因此通过该方式进行创建。
  • 总结创建成员内部类对象：
    • 外部类名.内部类名 引用名字 = new 外部类().new 内部类();
  • 总结外部类访问成员内部类成员：
    • 创建内部类对象，通过( 对象. )的方式进行访问

class Outer{
		private int num = 10;
		class Inner{
			public void print(){
				System.out.println("你好");
			}
		}
}
class Demo{
		public static void main(String[] args){
			//创建内部类对象
			Outer.Inner  oi  =  new  Outer().new Inner();
			oi.print();
		}
}

• 外部类如何访问private权限下成员内部类的成员?
  • 总结访问私有内部类成员：
    • 在外部类中创建一个方法，在该方法中创建内部类对象，并调用内部类成员方法或者属性，再在需要使用的地方创建外部类对象，通过( 对象. )的方法访问在外部类中创建的这个方法即可

public class   Outer{
		private  class   Inner{
			public void print(){
				System.out.println("你好");
			}
		}
		//因为私有的成员无法被外界访问，但在本类中可以被访问
		public void method(){
			//创建内部类对象，本类中可以访问private权限
			Inner  i  =  new  Inner();
			//print()这样的被称作语句，语句只能写在方法中
			i.print();
		}
}
class Demo{
		public static void main(String[] args){
			//创建内部类对象
			Outer  o  =  new  Outer(); 
			o.method();
		}
}

• 外部类如何访问static权限下成员内部类的成员?
  • 解释： 因为内部类是静态的，而静态的成员可以通过( 类名. )的方式进行访问，因此创建内部类对象的语句为Outer.Inner io = Outer.new Inner()，但由于我们习惯将new关键字放在前面，所以将其改变成了Outer.Inner io = new Outer.Inner()，左边创建引用的含义参照上面的含义

public class   Outer{
		static  class   Inner{
			public void print(){
				System.out.println("你好");
			}
		}
}
class Demo{
		public static void main(String[] args){
			//根据习惯改进：
			//Outer.Inner  io  =  Outer.new Inner();
			Outer.Inner  io  =  new  Outer.Inner();
			io.print();
		}
}

• E：内部类的访问特点
  • (1) 内部类可以直接访问外部类的成员，包括私有的
    • 解释：这是因为在访问外部类的成员时，前面省略了( 外部类名.this )
  • (2) 外部类想要访问内部类的成员，必须先创建对象

class   Outer{
		private int num = 10;
		class   Inner{
			public void print(){
				System.out.println(num);
			}
		}
}
class Demo{
		public static void main(String[] args){
			//创建内部类对象
			Outer.Inner  oi  =  new  Outer().new Inner();
			oi.print();
		}
}

Day10.04_____局部内部类

• 局部内部类是什么？
  • 定义在方法中的类叫做局部内部类
• 外部类如何访问局部内部类的成员
  • 总结：
    • 访问局部内部类中的成员，只能在局部内部类存在的外部方法中去访问，这种方法一般不回用

class   Outer{
		public void method(){
			//局部内部类访问时，必须为final状态
			final  int  num  =  10;
			class   Inner{
				public void print(){
					System.out.println(print);
					System.out.println(num);
				}
			}
			//由于局部内部类只在method( )方法中有效，所以出了这个方法后生命就结束了，因此只能在该方法中进行对象的创建
			Inner  inner = new Inner();
			inner.print();
		}
}
class Demo{
		public static void main(String[] args){
			Outer outer = new Outer();
			outer.method();
		}
}

Day10.05_____匿名内部类

• 匿名内部类实现的前提：
  • (1) 必须继承一个类或者一个接口
  • (2) 必须放在一个方法中或方法上
• 匿名内部类格式：
  • new 接口或类名( ){
    需要重写的方法…
    }
• 匿名内部类的定义：

interface Inter{
		public void show();	
}
class   Outer{
		/**
			class  Inner implements Inter{
				public void show(){
					System.out.println("method")
				}
				public void print(){
					System.out.println("print");
				}
			}
			public  void  creatObject(){
				Inner  i  = new  Inter();
				i.print();
			}
		*/
		/**  
		 *      将上面有名字的简化，解析如下：
		 *	(1) new Inter()表示实现Inter这个接口，和上面implements Inter是一个意思
		 *	(2) new Inter(){}表示创建一个Inter的子类对象，这里使用的方式是父类引用指向子类对象，相当于上面的Inter  i  = new  Inner()
		 *	(3) {}中的内容是，如果是通过接口创建的匿名内部类，那么里面就是需要重写的接口中的方法；如果是通过继承类创建的匿名内部类，那么里面就是需要重写的方法
		 */
		public void method(){
			new Inter(){
				public void show(){
				       System.out.println("show");
				}
			}.show();
		}
	}
	class Demo{
		public static void main(String[] args){
			Outer outer = new Outer();
			outer.method();
		}
	}

• 匿名内部类使用的注意事项：
  • 使用匿名内部类最好是实现的接口或者继承的类中只有一个需要重写的方法
    
    
    

Day10.06_____匿名内部类在开发中的应用

• 匿名内部类当作参数传递，此时的匿名内部类是局部内部类的一种。这样做的好 处是我们不用再去写一个类去继承抽象类，节省了内存

abstract class Person{		//抽象类不能实例化对象
		public void method();
}
class PersonDemo{
		public void printPerson(Person p){
			p.method();
		}
} 
class Demo{
		public static void main(String[] args){
			PersonDemo p = new PersonDemo();
			p.printPerson(new Person(){
				public void method(){
					Sys("method");
				}
			})；
		}
}