day14_innerClass&modifier

  • 权限修饰符
  • 内部类
  • 引用类型
  • Object类
  • 常用API

权限修饰符

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

设计细节:

  • ​ 成员变量:使用private ,隐藏细节
  • ​ 构造方法:public ,方便创建对象
  • ​ 成员方法:建议使用public ,方便调用

如果一个类被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("吃骨头");
            }
        });
    }
}

引用类型用法总结

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

上一篇:AlphaGo可能会发现另外一种围棋的美,是我们想象不到的


下一篇:Postgresql vacuum freeze相关参数