面向对象（常见修饰符和内部类）

一 常见修饰符
1- 权限修饰符 private
私有的 ，可以修饰成员变量，构造方法，成员方法。修饰的成员只能在本类中调用；
2-权限修饰符 默认的
可以修饰类，成员变量，构造方法，成员方法,修饰的可以在同一个包（子类和无关类）下调用；
3-权限修饰符 protected
受保护的，可以修饰成员变量，构造方法，成员方法，修饰的可以在不同包下调用（子类）；
4-权限修饰符 public
公众的，可以修饰成员变量，构造方法，成员方法，修饰的可以在不同包（无关类）下调用；
5-状态修饰符 static
静态的 ，可以修饰成员变量，成员方法。静态只能调用静态；
6-状态修饰符 final
最终的，可以修饰类，成员变量，成员方法。修饰的类不能被继承，成员变量当作常量，成员方法不能被重写；
7-抽象修饰符 abstract
抽象的，可以修饰类，成员方法。修饰的类一定要被继承，抽象方法只是一个声明，所以一定要被重写。
8- 面试题：
abstract不能和哪些关键字共存?
private 冲突
final 冲突
static 不能共存 无意义
二 内部类
1-内部类的概念：
把类定义在其他类的内部，这个类就被称为内部类。
按照内部类位置分类
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。

class B {
        //内部类：将一个类定义到，另一个类的内部，那么这个类，就叫做内部类
        //举例：例如将 A类定义到B类里面，A类叫做内部类，B类叫做外部类
        //根据定义的位置不同，分为成员内部类，和 局部内部类
        // 成员内部类：这个内部类，在外部类的成员位置
        // 局部内部类：将内部类，定义到外部类的方法中

    //成员内部类
    class A {

    }

    public void show() {
        //局部内部类
        class C {

        }
    }
    }

2-内部类访问特点
a:内部类可以直接访问外部类的成员，包括私有。
b:外部类要访问内部类的成员，必须创建对象。

public class Outer {

    int num = 10;
    private int a = 100;
    
    //定义成员内部类
    class Inner {
        int b = 109;
        
        public void innerShow() {
            System.out.println("内部类的show方法");
        }
        
        //内部类可以直接访问外部类的成员，包括私有
        
        public void innerTest(){
            System.out.println(num);
            System.out.println(a);
            outerShow();
            outerTest();
        }
    }

    public void outerShow() {
        System.out.println("这是外部类的show方法");
    }

    private void outerTest() {
        System.out.println("这是外部类的show方法");
    }
    //外部类，想要访问内部类的成员，得创建内部类的对象
    public void method(){
        //创建内部类的对象
        Inner inner = new Inner();
        System.out.println(inner.b);
        inner.innerShow();
    }
}

public class MyTest {
    public static void main(String[] args) {
        Outer outer = new Outer();
        System.out.println(outer.num);
        outer.outerShow();
        System.out.println("--------------------------------");
        //使用成员内部类的属性和方法
        //创建成员内部类的语法
        //如何在测试类中直接访问内部类的成员。
	//格式: 	外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer.Inner inner=new Outer().new Inner();
        System.out.println(inner.b);
        inner.innerShow();
        System.out.println("---------------");
        outer.method();
    }
}

3-内部类被private修饰
内部类被private修饰了，外键就不能直接创建内部类对象了

public class MyTest {
    public static void main(String[] args) {
        //创建内部类的对象
        //内部类被private修饰了，外键就不能直接创建内部类对象了
        //Wai.Nei nei = new Wai().new Nei();
        Wai wai = new Wai();
        wai.waiShow();
    }
}


class Wai{
    //private 可以修饰内部类
    private class Nei{
        int num=10;
        public void neiShow(){
            System.out.println("内部类的show方法");
        }

    }

    public void waiShow(){
        Nei nei = new Nei();
        System.out.println(nei.num);
        nei.neiShow();
    }
}

4-内部类被static修饰
（1） 内部类被静态修饰后，创建内部类的语法要改变；
（2）静态内部类要访问外部类的成员只能访问静态的

public class MyTest {
    public static void main(String[] args) {
        //内部类被静态修饰后，创建内部类的语法要改变
        //静态内部类要访问外部类的成员只能访问静态的
        Wai.Nei nei = new Wai.Nei();
    }
}
 
class Wai {
    static int num = 10;
    private int a = 100;

    static class Nei {
        public void neiShow() {
            System.out.println(num);
            waiShow();
        }
    }

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

5-局部内部类，外界不能直接创建其对象

public class Outer {
    int num=10;
    private int a=100;
    public void waiShow(){
        //定义局部内部类
        //内部类可以直接访问外部类的成员，包括时私有的
        class Inner{
            int c=1;
            public void neiShow(){

                System.out.println(c);
                System.out.println(num);
                System.out.println(a);
            }

        }
        Inner inner = new Inner();
        inner.neiShow();
    }

    public void waiTest(){
       waiShow();
    }

}

public class MyTest {
    public static void main(String[] args) {
        //局部内部类，外界不能直接创建其对象
        Outer outer = new Outer();
        outer.waiTest();
    }
}

6- 局部内部类，访问外部类的局部变量，局部变量必须加上final修饰 为什么？
因为局部变量会随着方法的调用完毕而消失 ，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用

• List item

，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

class Wai {
int b = 100;//成员变量

public void show(final int a) {
    //局部变量
    final int num = 10;
    class Nei {
        public void neiShow() {
            //局部内部类，访问外部类的局部变量，局部变量必须加上final修饰，JDK1.8 默认就加上了
            System.out.println(num);
            System.out.println(a);
        }
    }
}

}
三 匿名内部类
1-匿名内部类: 就是局部内部类的简化写法，本质上是一个继承了该类或者实现了该接口的子类匿名对象，存在一个类或者接口;这里的类可以是具体类也可以是抽象类。

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

2-例题

 public class MyTest {
    public static void main(String[] args) {
    AA a = new B();
    a.show();
     }
}

abstract class AA{
    public abstract void show();
}

class B extends AA{
   @Override
   public void show() {
   System.out.println("重写了show方法");
   }
   }

用内部类实现上题中的show方法

public class MyTest {
    public static void main(String[] args) {
    
        new AA(){
            @Override
            public void show() {
                System.out.println("重写了show方法");
            }
        }.show();

    }
}

abstract class AA{
    public abstract void show();
}