类的高级特性

package com.java.exp11;

import java.util.Random;
import static java.lang.System.out;

/**
 * 1、Java类包
 *  1.1、类名冲突
 *      将两个类放在不同的包下
 *  1.2、完整的类路径
 *      同一个包汇总的类相互访问时，可以不指定包名
 *  1.3、创建包
 *      Java包的命名规则是全部使用小写字母
 *  1.4、导入包
 *      import关键字
 *      还可以导入静态成员  import static 静态成员
 * 2、final变量
 *  final声明的变量不能改变，通常，有final定义的变量为常量
 *  final关键字定义的变量必须在声明的时候对其进行赋值操作
 *  在Java中声明全局常量，通常使用 public static final 修饰，这样的常量只能在定义是赋值
 * 3、final方法
 *  final方法不能被重写
 * 4、final类
 * 5、内部类
 *  5.1、成员内部类
 *      1.成员内部类简介
 *      在一个类中使用内部类，可以再内部类中直接存取其所在类的私有成员变量
 *      在内部类中可以随意使用外部类的方法以及成员变量，尽管这些类成员被修饰为private。
 *      如果在外部类和非静态方法之外实例化内部类对象，需要使用外部类。内部类的形式指定该对象的类型。
 *      内部类对象会依赖与外部类对象，除非已经存在一个外部类对象，否则类中不会出现内部类对象。
 *      2.内部类向上转型为接口
 *      非内部类不能被声明为private或protected访问类型
 *      3.使用this关键字获取内部类与外部类的引用
 *  5.2、局部内部类
 *  5.3、匿名内部类
 *  5.4、静态内部类
 *  5.5、内部类的继承
 * */

class Parents{
    private final void doit(){
        System.out.println("父类.doit()");
    }
    final void doit2(){
        System.out.println("父类.doit2()");
    }
    public void doit3(){
        System.out.println("父类.doit3()");
    }
}
class Sub extends Parents{
    public final void doit(){       //在子类中定义一个doit()方法
        System.out.println("子类.doit()");
    }
//  final void doit2(){             //final方法不能被覆盖
//      System.out.println("子类.doit2()");
//  }
    public void doit3(){
        System.out.println("子类.doit3()");
    }
}
public class Demo {
    public static void main(String[] args) {
        Sub s = new Sub();
        s.doit();
        Parents p = s;
//      p.doit();           //不能调用private方法
        p.doit2();
        p.doit3();
    }
}

InterfaceInner类

package com.java.exp11;

/**
 * 成员内部类--向上转型为接口
 * */
interface OutInterface{
    public void f();
}

class OuterClass2{
    //定义一个内部类实现Out Interface接口
    private class InnerClass implements OutInterface{
        InnerClass(String s){       //内部类构造方法
            System.out.println(s);
        }
        public void f(){            //实现接口中的f()方法
            System.out.println("访问内部类中的f()方法");
        }
    }
    public OutInterface doit(){     //  定义一个方法，返回值类型为OutInterface 接口
        return new InnerClass("访问内部类构造方法");
    }
}


/**
 * 局部内部类
 * */
interface OutInterface2{

}
class OuterClass3{
    public OutInterface2 doit(final String x){      //doit()方法参数为final类型
        //在doit()方法中定义一个内部类
        class InnerClass2 implements OutInterface2{
            InnerClass2(String s){
                s = x;
                System.out.println(s);
            }
        }
        return new InnerClass2("doit");
    }
}

/**
 * 匿名内部类
 * */
class OuterClass4{
    public OutInterface2 doit(){
        return new OutInterface2(){
            private int i = 0;
            public int getValue(){
                return i;
            }
        };
    }
}

public class InterfaceInner{
    public static void main(String[] args){
        OuterClass2 out = new OuterClass2();    //实例化一个OuterClass2对象
        //调用doit()方法，返回一个OutInterface接口
        OutInterface outinter = out.doit();
        outinter.f();
    }
}

OuterClass类

package com.java.exp11;

public class OuterClass {
    InnerClass in = new InnerClass();   //在外部类实例化内部类对象引用
    public void ouf(){
        in.inf();                       //在外部类方法中调用内部类方法
    }
    class InnerClass{
        InnerClass(){                   //内部类构造方法
        }
        public void inf(){              //内部类成员方法
        }
        int y = 0;
    }
    public InnerClass doit(){           //外部类方法，返回值为内部类引用
    //  y = 4;                          //外部类方法不能直接访问内部类成员变量
        in.y = 4;
        return new InnerClass();        //返回内部类引用
    }
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        //内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现
        OuterClass.InnerClass in = out.doit();
        OuterClass.InnerClass in2 = out.new InnerClass();
    }
}

OutputInnerClass类

package com.java.exp11;

/**
 * 内部类的继承
 * 
 * 当某个类继承内部类时，必须硬性给予这个类一个带参数的构造方法，
 * 并且这个构造方法的参数为需要继承内部类的外部类的引用，
 * 同时在构造方法体中使用 外部类引用.super()语句，这样才为继承提供了必要的对象引用
 * */
public class OutputInnerClass extends ClassA.ClassB{
    public OutputInnerClass(ClassA a){
        a.super();
    }

}
class ClassA{
    class ClassB{

    }
}

StaticInnerClass类

package com.java.exp11;

/**
 * 静态内部类
 * 静态内部类不可以使用外部类的非静态成员
 * 如果创建静态内部类的对象，不需要其外部类的对象
 * 不能从静态内部类的对象中访问非晶态外部类的对象
 * */
public class StaticInnerClass{
    int x = 100;
    static class Inner{
        void doitInner(){
//          System.out.println("外部类"+x);
        }
        public static void main(String[] args){
            System.out.println("a");
        }
    }
}

TheSameName类

package com.java.exp11;

public class TheSameName {
    private int x; 
    private class inner{
        private int x = 9;
        public void doit(int x){
            x++;                    //调用的时形参x
            this.x++;               //调用内部类的变量x
            TheSameName.this.x++;   //调用外部类的变量x
        }
    }
}