Java基础（七）内部类（方法内部类、成员内部类、静态内部类、匿名内部类）、包

内部类

类/接口中再次定义类

1.类里再次定义类

1）方法内部类

在方法内定义类
可以定义所有的非静态信息以及静态常量
可以正常的继承和实现
不能被访问权限符来修饰但是可以被abstract以及final来修饰
可以获取外部类所有的信息
只能获取当前方法的常量信息

代码：

package cn.tedu.inner;

public class InnerDemo1 {
    public static void main(String[] args) {
        //创建外部类的对象调用方法执行创建内部类对象的语句
        new Outer1().m();
    }

}
//外部类
class Outer1{
    //属性
    static int k=1;
    //方法
    public void m(){
        int y=1;//在jdk1.8以前需要手动添加final才变成常量
                //在jdk1.8及其以后底层会自动添加final才变成常量
                //但是如果手动添加了，底层就不再添加
        //方法内部类
        //可以定义所有非静态信息以及静态常量
        //可以正常的继承与实现
        //不能被访问权限符修饰但是可以被abstract以及final来修饰
        //可以获取外部类所有的信息
        //只能获取本方法的常量
        //方法内部类对象怎么创建？
        class Inner1 extends Object implements Cloneable{
            int x=1;
            public void n(){
                System.out.println(k);
                System.out.println(y);
            }
        }

        //创建方法内部类的对象
        Inner1 in=new Inner1();
        in.n();
    }
}

执行结果：

2）成员内部类

在成员位置定义类
可以定义所有的非静态信息以及静态常量
可以正常的继承和实现
可以被访问权限符以及abstract以及final来修饰
可以获取外部类所有的信息
Outer2.Inner2 inner2=new Outer2().new Inner2();//创建成员内部类对象

package cn.tedu.inner;

public class InnerDemo2 {
    public static void main(String[] args) {
        //创建成员内部类对象
        //Outer2.Inner2表示内部类
        Outer2.Inner2 inner2=new Outer2().new Inner2();
    }

}

class Outer2{
    //属性
    static int k=1;

    //非静态属性
    //Inner2 inner2=new Inner2();


    //成员内部类
    //可以定义所有的非静态信息以及静态常量
    //可以正常的继承和实现
    //成员变量可以被访问权限修饰符以及abstract、final修饰
    //可以获取外部类所有的信息
    class Inner2 extends Object implements Cloneable{
        static final int x=1;
        public void n(){
            System.out.println(k);
            m();
        }
    }
    //方法
    public void m(){}
}

3）静态内部类

在成员位置定义被static修饰的类
可以定义所有信息
可以进行正常的继承和实现
可以被访问权限符以及abstract和final来修饰
只能获取外部类的静态信息
static修饰的类一定是内部类
Outer3.Inner3 inner3=new Outer3.Inner3();//创建静态内部类对象

package cn.tedu.inner;

public class InnerDemo3 {
    public static void main(String[] args) {
        //创建静态内部类对象
        Outer3.Inner3 inner3=new Outer3.Inner3();
    }

}
//外部类
class Outer3{
    //属性
    static int k=1;

    //静态内部类
    //可以定义所有信息
    //可以进行正常的继承和实现
    //可以被访问权限符以及abstract和final来修饰
    //只能获取外部类的静态信息
    //static修饰的类一定是内部类
    static class Inner3 extends Object implements Cloneable{
        static final int x=1;
        public void n(){
            System.out.println(k);
        }
    }

    //方法
    public void m(){}
}

4）匿名内部类

默认继承类/默认实现接口，重写抽象方法
可以被继承的类/接口具有匿名内部类形式
只能使用一次
使用场景—参数传递

package cn.tedu.inner;

public class InnerDemo4 {
    public static void main(String[] args) {
        //创建抽象类子类对象
        /*D d=new D();
        d.m();*/

        //匿名内部类
        //继承类，重写抽象方法，创建匿名内部类对象
        //当类可以被继承/是接口时，拥有匿名内部类的形式
        //只能使用一次
        C c=new C(){
            @Override
            public void m() {
                System.out.println(1);
            }
        };
        c.m();

        //普通类也具有匿名内部类的形式
        B b=new B(){};

        //接口也具有匿名内部类的形式
        A a=new A() {
        };
        
        //调用方法
        //匿名内部类当做参数使用
        m(new A(){});
    }

    public static void m(A a){//只能接收接口的实现类对象
        
    }
}

//接口
interface A{}
//普通类
class B{}

//抽象类
abstract class C{
    public abstract void m();
}
class D extends C{

    @Override
    public void m() {

    }
}

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

package cn.tedu.inner;

public class InnerDemo5 {
    public static void main(String[] args) {
        System.out.println(Outer5.Inner5.i);
        System.out.println(Outer5.Inner6.j);
        System.out.println(Outer5.Inner5.Inner7.x);
    }
}

interface Outer5{

    //接口里定义接口，默认被static修饰
    interface Inner6{
        int j=1;
    }
    //接口里定义内部类默认被static修饰
    class Inner5{
        static int i=1;

        //类里定义接口
        static interface Inner7{
            int x=1;
        }

    }


}

包

1、使用方式：

a.声明包–package：告知程序当前定义类/接口所在的位置，只能出现一次且出现在首行
b.导入包–import：把和当前位置不在一个包下的类/接口的位置告知程序，可以出现多次且不在首行
（* ：通配符—可以当前包下所有的类/接口都能匹配过来）

package cn.tedu.packagex;

//*代表通配符，匹配util包下的信息
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class PackageDemo {
    public static void main(String[] args) {
        new Scanner(System.in);
        /*Arrays.sort();
        ConcurrentHashMap*/
    }
}

2、提供包

1）Java（源生包）
lang包：当程序启动时必须加载的信息（核心类库）
util包：提供大量的类/接口（工具包）
io包：数据传输
math包：提供的是简单的数学运算
net包：网络编程
nio：高并发
sql包：操作数据库
time包：提供日期和时间
2）Javax（扩展包）
3）org（第三方厂商提供的包）