其他分享
首页 > 其他分享> > day14_innerClass&modifier

day14_innerClass&modifier

作者：互联网

权限修饰符

	 *	java中 有四种权限修饰符
	 *		                        public    >   protected    >    default(缺省)    >    private 
	 *		          同类         	yes			 yes			  yes				yes
	 *		          同包		    yes			 yes			  yes			    no
	 *		          不同包子类		  yes		   yes			    no				  no
	 *		          不同包非子类	 yes		   no			   no				 no
	 *		          
	 *		          注意事项：default并不是权限修饰符关键字，意思是默认不写。

设计细节：

如果一个类被public修饰了，那么该类对应的源文件.java的文件名需要和类名完全一致

内部类

  如果一个事物的内部包含另一个事物，那么这就是一个类的内部包含了另一个类
  例如：身体和心脏的关系    “has - a”的关系  包含关系，心脏属于身体的一部分

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

	 * 成员内部类的定义格式：
	 * 		修饰符 class 外部类名{
	 * 				//...
	 * 			修饰符 class 内部类名{
	 * 				//...
	 * 			}
	 * 		}
	 *访问特点：
     *        内部类访问外部类信息，随意访问；
	 * 		 外部类访问内部类的，需要内部类对象
	 * ===============================================
	 * 备注：内部类仍然是一个独立的类，编译之后依然生成一个独立的.class文件，该文件名称：
     *   											 外部类类名$内部类名.class 
     * 
	 * 如何使用成员内部类？有两种方式：
	 * 1.间接使用方式：在外部类的方法当中使用内部类
	 * 2.直接使用方式：公式：
	 * 					类名称  对象名  = new  类名称
	 * 	【外部类类名.内部类类名对象名 = new 外部类名().new 内部类名();】
     示例：
         //使用内部类   链式调用  直接方式
		Body.Heart heart1 = new Body().new Heart();
		heart1.beat();
		new Body().new Heart().beat();
		
		//第二种写法(分开调用)
		Body body = new Body();
		Heart heart2 = body.new Heart();
		heart2.beat();

 * 当一个类是定义在方法内部，这个类是局部内部类
 * “局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了
 * 
 * 定义格式：
 * 		修饰符 class 外部类名称{
 * 			
 * 			修饰符   返回值类型   外部类方法名(参数列表){
 * 				class 局部内部类名称{
 * 					//...
 * 				}
 * 			}
 * 			//...
 * 		}
 * 局部内部类：如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效的final】
 * 备注：JDK1.8开始，只要局部变量事实不变，那么final关键字可以省略不写。
 * 
 * 原因如下：
 * 		1.new出来的对象保存在堆内存中
 * 		2.局部变量随着方法的压栈而在内存当中存储
 * 		3.方法运行结束后，立刻弹栈，局部变量也随之消失
 * 		4.但是new出来的对象不会随着方法的弹栈而消失，JVM会将它当作垃圾
 * 		生命周期产生冲突，so要变成final型
 * 
 * 	类的权限修饰符
 * 		1.外部类   public / default   only public, abstract & final are permitted
 * 		2.成员内部类  public / protected / default / private
 * 		3.局部内部类  什么都不能写

匿名内部类

​ 是内部类的简写，其本质是一个带着具体实现``父类或父接口的``匿名的子类对象

开发中，最常用到的内部类是【匿名内部类】

前提

​ 匿名内部类必须【继承一个父类】或者【实现一个接口】，伴随着重写父类或父接口当中的抽象方法

 * 以往的操作：想要使用接口中的方法，需要4步操作
 * 	1.定义实现接口的实现类
 * 	2.重写接口中的方法
 * 	3.构建子类的对象，把子类赋给父接口变量
 * 	4.通过父接口变量调用接口中的方法********************
 * 
 * so  我们需要使用匿名内部类
 * 接口名称  对象名 = new 接口名称(){
 * 		//覆盖重写接口当中的所有的抽象方法
 * };
 * 如果接口中的实现类（或父类的子类）在程序中只需要使用唯一的一次，
 * 那么在这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】
 * 
 * 解释：
 * 		new 接口名称(){};
 * 		1.new 代表创建对象
 * 		2.接口名称就是匿名内部类需要实现的那个接口，此时需要创建哪个接口实现类的对象
 * 		3.{}这是匿名内部类的内容
 * 注意事项：
 * 		1.匿名内部类，在创建对象时，只能使用唯一一次
 * 		如果希望多次创建对象，而且你、类的内容是一样的，建议去单独定义实现类
 * 		2.匿名对象，在调用方法时，只能使用唯一一次
 * 		如果希望同一个人对象，多次调用方法，建议给对象起名字
 * 		3.匿名内部类省略了【实现类/子类】，但是匿名对象是省略了对象名
 * 		4.匿名内部类和匿名对象根本不是一回事
 * 
 * MyInterface myInterface = new MyInterface(){
 * 		@Override
 * 		//...
 * };
 * myInterface.xxx();
 * MyInterface myInterface = new MyInterface(){
 * 		@Override
 * 		//...
 * }.method01;//匿名内部类匿名对象

​ 通常在方法的形式参数是接口或抽象类时，一般将匿名内部类作为参数实参传递进去

public interface Animal{
    void eat();
    void sleep();
}
//定义启动类
public class AnornymousDemo{
    //定义成员方法
    public static void showEat(Animal animal){
        animal.eat();
    }
    //多态的写法   左边：接口   右边：子类对象
    public static void main(String []args){
        Animal animal = new Animal(){ //相当于一个实现类对象
            @Override
            public void eat(){
                System.out.println("吃鱼"); 
            }
        };
        showEat(animal);//吃鱼  animal是一个对象
        showEat(new animal(){   //匿名内部类的匿名对象
             @Override
            public void eat(){
                System.out.println("吃骨头");
            }
        });
    }
}

引用类型用法总结

​ 接口可以作为成员变量，然后通过匿名内部类的方式，重写接口

标签：innerClass,内部,接口,day14,匿名,new,yes,modifier,public
来源： https://www.cnblogs.com/mitoris/p/14044832.html