内部类，包

 

内部类

类里有类：

　　1.方法内部类

　　2.成员内部类

　　3.静态内部类

　　4.匿名内部类

 

方法内部类

　　在外部类的方法中定义了一个类

　　可以定义非静态的属性和方法

　　可以拿到外部类所有的属性和方法

　　只能拿到本方法中的常量

　　可以正常的继承与实现，被final以及abstract修饰

public class InnerDemo {
    public static void main(String[] args) {
    }
}
​
class Outer{
    int j=1;
    public void m(){
        int h=9;        //隐式常量：从jdk1.8开始在方法内部类本方法中的变量，默认添加final操作
                        //显示常量：jdk1.7之前，需要手动添加final
        //方法内部类
        //只能定义非静态的属性和方法
        //可以定义静态常量
        //可以继承与实现
        //可以拿到外部类所有的属性和方法
        //只能拿到本方法中的常量
        //方法内部类对象---要再本方法中创建对象
        //可以被final或static修饰
        class inner1{
            //属性
            final static int i=10;      //可以定义静态常量
            public void mn(){
                System.out.println(h);  //只能拿到本方法中的常量
                
                System.out.println(j);  //可以拿到外部类所有的属性和方法
                n();                    //可以拿到外部类所有的属性和方法
            }
            
        }
        //-----------创建方法内部类对象--------------------
        inner1 inner1 = new inner1();
        inner1.mn();
        
    }
    
    public void n(){
        
    }
}
​
class outer{
    
}
​
​
interface outer2{
    
}

 

 

成员内部类

　　在类内，方法外定义了一个类

　　可以定义所有非静态的属性和方法以及静态常量

　　可以拿到外部类的所有属性和方法

　　可以继承与实现

　　可以被访问权限修饰符修饰以及final,abstract

public class InnerDemo {
    public static void main(String[] args) {
        // ----------创建 成员内部类对象-----------
        Outer.inner2 inner2 = new Outer().new inner2();
        inner2.n();
    }
}
​
class Outer {
    int j = 10;
​
    // 成员内部类
    // 可以定义所有的非静态属性和方法以及静态常量
    // 可以拿到外部类所有属性及方法
    // 可以继承和实现
    // 可以被访问权限修饰符修饰以及final,abstract
    class inner2 extends InnerDemo implements Cloneable {
        int i = 1;
​
        public void n() {
            System.out.println(j); // 可以拿到外部类所有属性
            m(); // 可以拿到外部类所有方法
        }
    }
​
    public void m() {
    }
}
​

 

 

静态内部类

　　在类内，方法外，定义一个Static修饰的类

　　可以定义所有的属性和方法

　　只能拿到外部类的静态属性和方法

　　可以继承与实现

　　可以被访问权限修饰符修饰以及final和abstract

扩展 A.B.i 的三种形式

　　1.如果A是对象，B是A对象类的属性，i是B属性对应类的属性

　　2.A是一个类，B是静态属性，i是B属性对应的类的属性

　　3.A是一个类，B是一个类，i是B类中的静态属性

public class InnerDemo {
    public static void main(String[] args) {
        //----------创建  静态内部类对象-------------
        Outer.Inner inner = new Outer.Inner();
        inner.n();
        //外部类.静态内部类.静态属性
        System.out.println(Outer.Inner.i);
    }
}
​
class Outer {
    
    static int j=5;
    
    //静态内部类
    //可以定义所有的属性和方法
    //只能拿到外部内静态的属性和方法
    //可以继承与实现
    //可以被访问权限修饰符修饰以及final,abstract
    static class Inner {
        //属性
        static int i=1;
        //方法
        public void n(){
            System.out.println(j);
        }
    }
    public void m(){}
}

 

匿名内部类

　　在类中没有名字的类

　　匿名内部类实质是在继承或者实现------类（可以被继承）或者接口，进行重写

　　匿名内部类在方法内，就按方法内部类使用，在成员就按成员内部类使用

public class InnerDemo {
    //匿名内部类出现在成员位置，就按成员内部类来使用
    D d = new D() {
        
        int j =10;
        @Override
        void m() {
            System.out.println(j);
        }
​
    };
    
    
    public static void main(String[] args) {
        // d对象是匿名内部类的对象
        // 匿名内部类 -----{ }没有名字的内部类
        // 匿名内部类的实质是继承一个类，可以进行重写
        //匿名内部类出现在方法中，就按方法内部类来使用
        D d = new D() {
            
            int j =10;
            @Override
            void m() {
                System.out.println(j);
            }
​
        };
​
        d.n();
​
        // 普通类也可以具有匿名内部类的形式（除了final修饰的类），可以进行重写
        B b = new B() {
        };
        
        //接口也可以具有匿名内部类的形式
        A a = new A(){};
    }
}
​
abstract class D {
    abstract void m();
​
    public void n() {
        System.out.println(2);
    }
}
​
class B {
​
}
​
interface A{
    
}

 

　　接口中的匿名内部类

　　接口定义内部类，以及内部接口，默认都是被static修饰

package test;
​
public class InnerDemo {
    //默认被静态修饰
    interface E{
        int i=1;    
    }
    
    public static void main(String[] args) {
        System.out.println(A.B.i);
        System.out.println(A.C.i);
        System.out.println(E.i);
    }
    
}
​
interface A{
    //默认被static修饰
    class B{
        static int i=10;
        
    }
    
    //默认被静态修饰
    interface C{
        int i=5;
    }
}

 

包：

　　声明包 package cn.tedu.day01

　　　　表示类在哪个位置，只能有一句且放在首行

　　导入包

　　　　和本类不在一个包下的引入，可以多句，且不能出现在首行

　　　　*：表示通配符，可以表示当前剥下的所有类

Java（原生包）

　　lang包：核心类库，在程序启动的时候，会自动加载包下的所有内容，使用的时候不用导包

　　util包：提供了大量的操作类与对象

　　applet，awt包：图形化界面

　　beans：框架时使用

　　io：数据传输

　　math：提供了简单的数学运算

　　net：网络数据传输

　　nio：高并发

　　secutity：安全

　　sql：操作数据库

　　text：格式化 3.46

　　time：提供了时间和日期

 

Javax（扩展包）

org（第三方厂商 Apache）