文章标题

1. 静态成员修饰符static
2. 最终修饰符final
3. 包的概念
4. 四种权限修饰符
5. 内部类
   静态成员修饰符static

/*
 * 静态成员修饰词static  //自古以来广大人民群众的
 * 静态修饰的成员保存在方法区的静态区，先于对象存在。
 * 静态修饰的成员被本类的所有对象共享
 * 非私有的成员可以被类名对象名调用
 * 由于先于对象存在所以静态的方法不能直接调用非静态的变量
 */
public class Test {
    public static void main(String[] args) {
        System.out.println(JingTai.a);
        JingTai.show();
    }
}

/*
 * 静态属性与静态代码块的赋值，与位置有关，谁在下，谁生效；
 */
public class JingTai {// 静态不能修饰类
    public JingTai() {
        super();
        System.out.println("空参构造");
        System.out.println(a);
        System.out.println("空参构造");
    }

    public static int a = 2;
    static {
        System.out.println(a);
        a = 5;
    }

    public static void show() {
        System.out.println(a);
        // System.out.println(b);//静态方法不能直接调用非静态变量
    }
}

最终修饰符final

public class Test {
    public static void main(String[] args) {
        /* p=new ZuiZong(); */// 修饰的引用类型 不能改变地址值
        /* p.a=9; */// 修饰的基本类型变量不能改变值
        ZuiZong z=new ZuiZong(3);
    }
}

/*
 * 最终修饰符final:  //神圣不可动摇
 * 可以修饰类，方法，属性
 * 修饰的类不能被继承
 * 修饰的方法不能被重写,可以重载。
 * 修饰的基本类型的变量，必须显性赋值，其值不可以改变
 * 修饰的引用类型的变量，地址值不变，但是内容可以改变。
 * 可以用构造方法给final修饰的成员属性赋值，但是此时，只能存在含有final的构造方法
 */
public /* final */ class ZuiZong {// 父类被修饰后不能被继承
    public int getA() {
        return a;
    }
    public final void show() {
        System.out.println("父类的最终修饰方法");
    }
    /*public final int b;*///不明确赋值报错
     final int a;
    public ZuiZong(int a) {
        super();
        this.a = a;
    }
}

四种权限修饰符

/*
* 四个权限修饰符
* public 最大范围 本类，本包，异包都能用，
* protected 本类，本包，异包的子类可用
* 空 （啥都不写） 本类，本包可用
* private 只有本类下才能用
*/

内部类

public class Test {
    public static void main(String[] args) {
        // 创建内部类对象的格式
        // 外部类.内部类 变量名 = new 外部类（）.new 内部类();
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
        Outer o = new Outer();
        // 外部类.内部类 变量名 = 外部类.new 内部类();
        Outer.Inner oi1 = o.new Inner();
        oi1.show();
        o.show();
        o.show1();
        Nei n = o.show2();
        n.show();
    }
}

/*
 * 内部类：类中类，类的组合关系
 * 局部内部类：定义在方法中，只能在方法内使用
 * 匿名内部类：没有类名的局部内部类//使用前提必须有父类或者接口
 */
public class Outer {// 定义格式
    public void show() {
        System.out.println("外部类");
    }

    public class Inner {
        public void show() {
            System.out.println("内部类");
        }
    }

    // 局部内部类的定义格式
    public void show1() {
        final int a = 10;// 变量加final修饰局部内部类才能使用
        class Part {
            public void show() {
                System.out.println(a);
                System.out.println("局部内部类");
            }
        }
        new Part().show();
    }

    // 匿名内部类的定义格式
    public Nei show2() {// 外部类的方法
        Nei n = new Nei() {// 创建内部类的同时，创建对象，一般创建后用多态接收。
            public void show() {
                System.out.println("匿名内部类1");// 匿名内部类为子类，要重写方法。
            }
        };// 一定要注意这个分号。

        new Nei() {
            public void show() {
                System.out.println("匿名内部类2");
            }
        }.show();// 匿名内部类创建完之后就是一个子类对象，可以直接调用方法。

        return n;
    }
}

public interface Nei {
    public abstract void show();
}