java基础知识（权限修饰符， 内部类， 匿名内部类）

java第九天之学到辽~

1.1 类及其组成所使用的常见修饰符

* 修饰符：

 权限修饰符：private，默认的，protected，public
 状态修饰符：static，final 
 抽象修饰符：abstract

* 修饰类的关键字：

权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
( 用的最多的就是：public )

* 修饰成员变量的关键字：

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
( 用的最多的就是：private )

* 修饰构造方法的关键字：

权限修饰符：private，默认的，protected，public
( 用的最多的就是：public )

* 修饰成员方法的关键字：

权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
( 用的最多的就是：public )

* 组合规则：

成员变量：public static final 
成员方法：public static 
         public abstract
         public final

1.2 内部类

* 内部类的概念

把类定义在其他类的内部，这个类就被称为内部类

* 内部类分类

按照内部类位置分类：
成员位置:在成员位置定义的类，被称为成员内部类
局部位置:在局部位置定义的类，被称为局部内部类

* 内部类访问特点

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

* 成员内部类

在测试类中直接访问内部类的成员：
格式:  外部类名.内部类名 对象名 = 外部类对象.内部类对象

* 成员内部类的常见修饰符及应用

（1）private 
（2）static
注意事项:  
  静态内部类访问的外部类数据必须用静态修饰
成员内部类被静态修饰后的访问方式是:
  格式: 外部类名.内部类名 对象名 = new 外部类名.内部类名()

* 成员内部类的例子

public class outer {

   int num = 10;

   private int a = 20;

   class Inner {
       int aa = 1;

       public void innnerShow() {
           System.out.println("内部类方法");
           System.out.println(num);
           System.out.println(a);
           waiShow();
           waiTest();
       }

   }

   public void waiShow() {
       System.out.println("外部类的方法");
   }

   private void waiTest() {
       System.out.println("外部类的私有方法");
   }
}


   class test {
       public static void main(String[] args) {
           outer.Inner aa = new outer().new Inner();
           aa.innnerShow();
       }
   }

* 局部内部类访问

可以直接访问外部类的成员

可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

* 局部内部类访问局部变量必须用final修饰

 因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内
 存中消失，还要使用那个变量。
 为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

1.3 匿名内部类

* 匿名内部类: 就是局部内部类的简化写法。

必须存在一个类或者接口;这里的类可以是具体类也可以是抽象类。

* 匿名内部类的格式：

new 类名或者接口名(){
 重写方法;
} ;

* 匿名内部类的本质

是一个继承了该类或者实现了该接口的子类匿名对象

* 匿名内部类的例子

* 通过接口的方式创建匿名内部类

interface Inter {

public abstract void show();

}

//在外部类Outer的method()方法中，创建匿名内部类

public class Outer {

     public static void main(String[] args) {

            new Inter(){

              @Override

              public 
void show() {

              System.out.println("哈哈哈哈哈哈哈哈");

          }

      }.show();

  }

}

interface Inter {

public abstract  void show();

}

* 通过抽象类的方式创建匿名内部类

public class Outer {



 public void method(){

     new AbstractClass(){

         @Override

         public void show() {

             System.out.println("嘻嘻嘻嘻嘻嘻嘻");

         }

     }.show();

 }



  public static void main(String[] args) {

      Outer outer = new Outer();

      outer.method();

  }
}

abstract class AbstractClass {

  public abstract void show();

}