JavaSE学习笔记（十）—— 权限修饰符&内部类

一、权限修饰符

　　在java中有四种权限修饰符：范围从大到小分别是：public、protect、default(friendly)、private,它们之间的区别是：

• public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。
• protect: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
• default:  这个访问权限可能是很多人容易所忽视的，即不写任何关键字。默认权限(同包权限)即：包内可访问，包外不可访问，不管是子类还是没有继承关系的类。
• private:  只能在当前类中使用，外部不能访问。

　　在同一个包的前提下，在继承时，子类只能继承父类中的public、protected以及default访问权限的成员变量或方法，并且继承之后，这些成员变量或方法的访问权限和之前的一样，如父类中是public，继承后还是public。

　　在不同包的前提下，在继承时，子类只继承父类中的public和protected访问权限的成员变量或方法作为子类自己的成员变量或方法。 

二、类及其组成可以用的修饰符

　　修饰符分为三种：权限修饰符、状态修饰符和抽象修饰符。

• 权限修饰符：private，default，protected，public
• 状态修饰符：static，final
• 抽象修饰符：abstract

【类】

　　权限修饰符：默认修饰符(default)，public
　　状态修饰符：final
　　抽象修饰符：abstract

　　其中，用的最多的是public

【成员变量】

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

【构造方法】

　　权限修饰符：private，默认的，protected，public

　　用的最多的就是：public

【成员方法】

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

三、内部类

3.1 内部类概述

　　把类定义在其他类的内部，这个类就被称为内部类。
　　举例：在类A中定义了一个类B，类B就是内部类。

3.2 内部的访问特点

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

class Outer {
    private int num = 10;
    
    class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    
    public void method() {
        //找不到符号
        //show();
    
        Inner i = new Inner();
        i.show();
    }
    
}

class InnerClassDemo {
    public static void main(String[] args) {
    
    }
}

3.3 内部类位置

　　按照内部类在类中定义的位置不同，可以分为如下两种格式： 

• 成员位置:在成员位置定义的类，被称为成员内部类。
• 局部位置:在局部位置定义的类，被称为局部内部类。

class Outer {
    private int num = 10;

    //成员位置
    /*
    class Inner {
        
    }
    */
    

    public void method() {
        //局部位置
        class Inner {
        
        }
    }
}

class InnerClassDemo2 {
    public static void main(String[] args) {
        
    }
}

3.4 成员内部类

【如何直接访问内部类的成员】

　　外部类名.内部类名 对象名 = 外部类对象.内部类对象;

class Outer {
    private int num = 10;
    
    class Inner {
        public void show() {
            System.out.println(num);
        }
    }
}

class InnerClassDemo3 {
    public static void main(String[] args) {
        //需求：我要访问Inner类的show()方法//格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

【成员内部类的修饰符】

　　private：为了保证数据的安全性

/*
    案例：我有一个人(人有身体，身体内有心脏。)
*/
class Body {
    private class Heart {
        public void operator() {
            System.out.println("心脏搭桥");
        }
    }
    
    public void method() {
        if(如果你是外科医生) {
            Heart h = new Heart();
            h.operator();
        }
    }
}

class BodyDemo{
    public static void main(String[] args) {
        //按照我们刚才的讲解，来使用一下
        Body.Heart bh = new Body().new Heart();
        bh.operator();
        //加了private后，就不能被访问了，那么，怎么玩呢?
        Body b =  new Body();
        b.method();
    }
}

　　static：为了方便访问数据

　　成员内部类被静态修饰后的访问方式是：外部类名.内部类名 对象名 = new 外部类名.内部类名();

class Outer {
    private int num = 10;
    //注意：静态内部类访问的外部类数据必须用静态修饰。
    private static int num2 = 100;
    
    //内部类用静态修饰是因为内部类可以看出是外部类的成员
    public static class Inner {
        public void show() {
            //错误: 无法从静态上下文中引用非静态变量 num
            //System.out.println(num);
            System.out.println(num2);
        }

        public static void show2() {
            //错误: 无法从静态上下文中引用非静态变量 num
            //System.out.println(num);
            System.out.println(num2);
        }        
    }
}

class InnerClassDemo4 {
    public static void main(String[] args) {
        //使用内部类
        //错误:限定的新静态类
        //new Outer()是一个对象，Inner是静态成员，类用static修饰后，是不能通过外部的对象访问的
        //Outer.Inner oi = new Outer().new Inner();
        //oi.show();
        //oi.show2();
        
        //成员内部类被静态修饰后的访问方式是:
        //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();
        oi.show2();
        
        //show2()的另一种调用方式
        Outer.Inner.show2();
    }
}

【成员内部类练习】

　　补齐程序(注意:内部类和外部类没有继承关系)

class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(?);
            System.out.println(??);
            System.out.println(???);
        }
    }
}

　　要求请填空，在控制台分别输出30，20，10。

class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);//30
            System.out.println(this.num);//20
            //System.out.println(new Outer().num);//10
            System.out.println(Outer.this.num);//10
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }    
}

3.5 局部内部类

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

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

class Outer {
    private int num  = 10;
    
    public void method() {
        //int num2 = 20;
        final int num2 = 20;
        class Inner {
            public void show() {
                System.out.println(num);
                //从内部类中访问本地变量num2; 需要被声明为最终类型
                System.out.println(num2);//20
            }
        }
        
        Inner i = new Inner();
        i.show();
    }
}

class InnerClassDemo5 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
} 

　　注意：局部内部类访问局部变量必须用final修饰！为什么呢？

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

3.6 匿名内部类

　　匿名内部类，就是内部类的简化写法。

【前提】

　　存在一个类或者接口（这里的类可以是具体类也可以是抽象类）

【格式】

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

【本质】

 　　匿名内部类的本质是，是一个继承了该类或者实现了该接口的子类匿名对象。

interface Inter {
    public abstract void show();
    public abstract void show2();
}

class Outer {
    public void method() {
        //一个方法的时候
        /*
        new Inter() {
            public void show() {
                System.out.println("show");
            }
        }.show();
        */
        
        //二个方法的时候
        /*
        new Inter() {
            public void show() {
                System.out.println("show");
            }
            
            public void show2() {
                System.out.println("show2");
            }
        }.show();
        
        new Inter() {
            public void show() {
                System.out.println("show");
            }
            
            public void show2() {
                System.out.println("show2");
            }
        }.show2();
        */
        
        //如果我是很多个方法，就很麻烦了
        //那么，我们有没有改进的方案呢?
        Inter i = new Inter() { //多态
            public void show() {
                System.out.println("show");
            }
            
            public void show2() {
                System.out.println("show2");
            }
        };
        
        i.show();
        i.show2();
    }
}

class InnerClassDemo6 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

【匿名内部类在开发中的使用】

　　首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，重点是接口的情况，我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，所以，可以使用匿名内部类改进以前的做法。

interface Person {
    public abstract void study();
}

class PersonDemo {
    //接口名作为形式参数
    //其实这里需要的不是接口，而是该接口的实现类的对象
    public void method(Person p) {
        p.study();
    }
}

//实现类
class Student implements Person {
    public void study() {
        System.out.println("好好学习,天天向上");
    }
}

class InnerClassTest2 {
    public static void main(String[] args) {
        //测试
        PersonDemo pd = new PersonDemo();
        Person p = new Student();
        pd.method(p);
        System.out.println("--------------------");
        
        //匿名内部类在开发中的使用
        //匿名内部类的本质是继承类或者实现了接口的子类匿名对象
        pd.method(new Person(){
            public void study() {
                System.out.println("好好学习,天天向上");
            }
        });
    }
}

【补充练习】

　　按照要求，补齐代码

interface Inter { 
    void show(); 
}
class Outer { 
    //补齐代码 
}
class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
    }
}

　　要求在控制台输出”HelloWorld”

interface Inter { 
    void show(); 
    //public abstract
}

class Outer { 
    //补齐代码
    public static Inter method() {
        //子类对象 -- 子类匿名对象
        return new Inter() {
            public void show() {
                System.out.println("HelloWorld");
            }
        };
    }
}

class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
        /*
            1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
            2:Outer.method().show()可以看出method()方法的返回值是一个对象。
                又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
        */
    }
}

参考：https://www.cnblogs.com/qq1871707128/p/6080189.html