Java学习day14--内部类、接口与抽象类区别

一、内部类

内部类 :类中定义类

内部类的访问特点：内部类访问外部类成员可以直接访问，包括私有

外部类访问内部类成员必须创建对象

//外部类
class Outer{
    private int num = 1;
//外部类成员属性方法

    //内部类
    class Inner{
        public void show(){
            //直接访问
            System.out.println(num)
        }
    }
    public void method(){
        //创建对象访问
        Inner in = new Inner();
        in.show();
    }

}

分类 :

1. 成员内部类：

定义：内部类定义在外部类的成员位置，可以被成员修饰符所修饰,可以继承其他父类,实现需要的接口,具有成员的特点,具有类的特点

特点 :

• 在成员内部类中只能定义非静态的成员内容,除了静态的常量

• 在成员内部类中可以直接使用所在外部类的成员,包括私有的

• 在所在外部类中需要通过成员内部类的对象访问其成员(包括私有成员),可以通过类名访问其静态的常量

• 在其他类中需要 通过外部类创建成员内部类对象,通过成员内部类对象访问其成员

成员内部类，外界（其他类）如何创建对象访问,创建内部类对象：

格式：外部类名.内部类名 对象名 = new 外部类对象.内部类对象

范例：Outer.Inner i = new Outer( ).newInner( );

public class Test01 {
    //外部类中的成员变量
    private int i = 1;
    private static int j = 2;

    //成员内部类
    class Inner{

        //内部类成员变量
        public int a = 3;
        //成员内部类中不能定义静态内容，只能定义被static final修饰的常量
        static final int b = 4;

        //内部类构造器
        public Inner() {
        }

        public Inner(int a) {
            this.a = a;
        }


        //内部类成员方法
        public  void inner(){
            System.out.println("内部类成员方法");
            System.out.println(i);
            System.out.println(j);
        }
    }


    public void outer(){
        System.out.println("外部类中的成员方法");
        //外部类通过
        System.out.println(Inner.b);
        //成员内部类对象
        Inner in = new Inner();
        System.out.println(in.a);
        //外部类中通过内部类对象访问内部类方法
        in.inner();
    }
}

2. 私有内部类

私有内部类是指：被private修饰的成员内部类

私有内部类中可以直接使用外部类的成员,包括私有的

在所在外部类中,通过私有内部类的对象访问其成员

其他类中无法使用私有内部类，其他类不能访问

public class Test03 {
    private int i = 1;
    private static int j = 2;

    //私有成员内部类
    private class Inner{
        //私有属性
        private int a = 5;
        private static final int b = 6;
        //内部类的方法
        public void test(){
            System.out.println("私有成员内部类中的成员方法");
            System.out.println(i);//私有内部类直接可以访问外部类成员
            System.out.println(j);
        }
    }
    //外部类成员方法
    public void outer(){
        //在外部类访问私有内部类的私有属性需要创建对象
        Inner in = new Inner();
        System.out.println(in.a);
        in.test();
    }
}

3. 静态内部类

静态内部类:被static修饰的内部类

• 静态内部类中可以根据需求定义静态|非静态

• 在静态内部类中可以直接使用所在外部类的静态内容，需要通过外部类的对象访问其成员

• 在所在外部类中可以通过类名访问静态内部类中的静态内容，需要通过对象访问静态内部类中的非静态成员

• 在其他类中可以通过外部类类名.内部类类名.静态内容访问内部类中的静态内容

• 在其他类中可以通过new 外部类类名.内部类类名()的内部类对象访问静态内部类中的成员内容

public class InnerTest04 {
    private int i = 1;
    private static int j = 2;

    //静态内部类
    static class Inner{
        int a = 10;
        static int b = 20;

        //静态内部类成员方法
        public void test(){
            System.out.println("静态内部类的成员方法");
            System.out.println(j);
            System.out.println(new InnerTest04().i);
        }

        //静态内部类的静态方法
        public static void testStatic(){
            System.out.println("静态内部类的静态方法");
            System.out.println(j);
            System.out.println(new InnerTest04().i);
        }
    }

    //外部类成员方法
    public void outer(){
        System.out.println("外部类的成员方法");
        //外部访问内部静态变量，通过类名访问
        System.out.println(Inner.b);
        Inner.testStatic();
        //外部访问内部成员变量，通过内部类对象访问
        Inner in = new Inner();
        System.out.println(in.a);
        in.test();
    }
}
//其他类
class F{
    public static void main(String[] args) {
        //其他类访问静态内部类的静态内容
        System.out.println(InnerTest04.Inner.b);
    }
}

4. 局部内部类

局部内部类 :定义在方法中的内部类为局部内部类

• 局部内部类中只能定义非静态的成员内容,除了静态的常量

• 在局部内部类中可以使用所在外部类的成员

• 局部内部类中如果一旦使用所在方法的局部变量(参数),这个局部变量必须为常量

jdk7及之前 : 要求必须手动被final修饰

jdk8及之后 : 默认被final修饰

• 只能在所在的方法中通过对象访问局部内部类的成员,在外部类中的其他方法中|其他类中都无法使用局部内部类

public class Class005_Outer {
    //成员
    private int a = 1;
    private static int b = 2;

    public void test(int args) {
        //局部
        int n = 10;
        //局部内部类
        class Inner{
            //成员
            int i = 10;
            static final int j = 20;

            public void test(){
                System.out.println(a);
                System.out.println(b);
                System.out.println(n);
            }
        }
        //测试使用局部内部类
        Inner  in = new Inner();
        System.out.println(in.i);
        in.test();
    }
    //测试使用外部类访问内部类：不可访问
    public void outer(){
        /*Inner  in = new Inner();
        System.out.println(in.i);
        in.test();*/
    }
}
//测试使用其他类访问：不可访问
class Test01{
    public void method(){       
        /*Inner  in = new Inner();
        System.out.println(in.i);
        in.test();*/
    }
}

5. 匿名内部类 ***

匿名内部类 :简化一些满足条件要求的实现类|子类,将定义实现类重写方法+创建实现类对象两步合并成一步

1)类没有自己本身作用

2)实现类|子类只在当前使用一次,不会重复使用多次

语法 :

        new 接口|抽象类( ){ --->实现类|子类类体
            重写方法....
        };

public class Class006_Outer {
    public static void main(String[] args) {
        //定义接口实现类
        //Demo demo = new Demo();
        //demo.swimming();

        //匿名内部类对象使用方式一 : 匿名对象-->对象只能在当前使用一次
        new Swim(){
            @Override
            public void swimming() {
                System.out.println("花样游泳....");
            }
        }.swimming();

        //匿名内部类对象的使用方式二 : 引用指向对象
        AbsClass abs = new AbsClass(){
            @Override
            void absMethod(boolean flag) {
                System.out.println("抽象类的子类"+flag);
            }
        };
        abs.absMethod(false);
        abs.absMethod(true);

        //匿名内部类使用方式三 : 作为方法的实参
        testSwim(new Swim() {
            @Override
            public void swimming() {
                System.out.println("仰泳...");
            }
        });

    }
    //游泳俱乐部,入场的都要会游泳的
    public static void testSwim(Swim swim){  //当方法的形参为一个接口类型,方法的实参就要为接口的实现类对象
        swim.swimming();
    }
}
//接口
interface Swim{
    void swimming();
}

//实现类
class Demo implements Swim{

    @Override
    public void swimming() {
        System.out.println("狗刨....");
    }
}
//抽象类
abstract class AbsClass{
    abstract void absMethod(boolean flag);
}

二、抽象类与接口区别

参数	抽象类	接口
实现	子类使用extends关键字来继承抽象类，如果子类不是抽象类，子类需要重写抽象类中的声明的抽象方法	子类使用关键字implements来实现接口。需要提供接口中所有声明的方法实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常类区别	除了抽象类不能实例化，和普通的Java类没区别	接口中所有的抽象方法默认被public abstract修饰的抽象方法
访问修饰符	抽象方法可以有public、protected和default	接口方法默认修饰符是public
main方法	抽象方法可以有main方法并且可以运行	不能定义main方法不能运行
多继承	抽象方法可以继承一个类和实现多个接口	接口可以继承多个其他接口
按需添加新方法	往抽象类中添加新方法，你可以给它提供默认的实现，不需要改变现在的代码	往接口中添加新方法，需要改变实现该接口的类