Java基础语法——抽象类、接口和内部类

书籍是最好的朋友。当生活中遇到任何困难的时候，你都可以向它求助，它永远不会背弃你。——都德

一、抽象类

定义：用abstract修饰的类（abstract不能与final连用 ）

存在的意义：被继承,父类中声明的方法由子类实现具体行为。

抽象方法：只有方法的声明，没有方法的具体实现
public abstract int count();

抽象类与普通类区别不大：不能创建对象

抽象类中可以有抽象方法（可以没有），子类必须重写所有的抽象方法，如果不想重写，子类也必须声明为抽象类。
有抽象方法的类一定是抽象类

实践代码，搓搓小手动起来(=!=)：

抽象类

public abstract class AbstractClass {
    //普通方法
    public String says(String str){
        return str;
    }
    //抽象方法
    public abstract String say(String str);

}

子类继承

public class SanAbstractClass extends AbstractClass {

    @Override
    public String say(String str) {
        return str;
    }
}

实现

public class TestAbstractClass {
    public static void main(String[] args) {
        SanAbstractClass s = new SanAbstractClass();
        String str = s.say("hello Abstract");
        System.out.println(str);
    }
}

二、接口

接口：通常用interface来声明

定义：一种约束，描述一类事物的功能
public interface InterfaceDemo {
…
}
属性：都是public static final 修饰的，默认的也为该权限

方法：默认都是public abstract 修饰的

接口不能创建对象，没有构造器

需要类去实现接口

类使用implements关键字实现接口

类实现接口时，必须重写所有的方法

类与类之间的关系是单继承，类与接口中的关系是多实现，接口和接口之间是多继承

接口和类的区别：

• 接口不能实例化对象

• 接口没有构造方法

• 接口中所有的方法都是抽象方法（例外：default ,static 修饰的方法必须有方法体，而且子类可以不重写该方法）

• 接口中所有成员变量默认都是public static final

• 接口不是被类继承，而是要被类实现

• 接口可以多继承，接口继承接口

接口和抽象类的区别：

• 抽象类中有构造方法，接口没有

• 抽象类可以有普通方法，接口只能抽象方法

• 抽象类的成员变量可以是什么类型，接口默认public static final

• 接口没有静态代码块和静态方法，抽象类可以有

• 一个类只能继承一个抽象类，一个类可以实现多个接口，一个接口可以继承多个接口

实践代码，搓搓小手动起来(=!=)：

接口InterfaceDemo

public interface InterfaceDemo {

    public void say();
    public void study();

}

Student类实现接口InterfaceDemo

public class Student implements InterfaceDemo{

    @Override
    public void say() {
        System.out.println("hello teacher");
    }

    @Override
    public void study() {
        System.out.println("study English");
    }

    public static void main(String[] args) {
        Student s = new Student();
        s.say();
        s.study();
    }
}

三、内部类

内部类: 在一个类内部进行其他类结构的嵌套操作
1.普通内部类：

• 可以用任何权限修饰符修饰

• 可以使用外部类的所有属性

• 创建内部类对象时，首先需要创建外部类对象，

• 外部类名.内部类名 变量名 = 外部类对象.new 内部类名();

2.静态内部类：

• 可以用所有权限来修饰

• 只能访问外部类的所有静态属性

• 外部类名.内部类名 变量名 = new 外部类名.内部类名();

3.局部内部类:

• 定义在方法中，只能在当前方法中使用，

• 不允许使用访问权限修饰符

• 能使用外部类中所有的属性,

• 针对于方法中的局部变量来说，能访问，但是不能修改值

4.匿名内部类：

• 就是一个没有名字的局部内部类

• 因此特点和方法与局部内部类完全一致

• 另外：
  匿名内部类必须继承一个抽象类或者实现一个接口
  匿名内部类没有类名，因此没有构造方法
  接口/类名 变量名 =new 接口/类 名(){
  重写接口的方法
  };
  调用：变量名.方法名();

优点：

内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
内部类是另外一种封装，对外部的其他类隐藏。
内部类可以实现java的单继承局限。

缺点：

结构复杂

实践代码，搓搓小手动起来(=!=)：

4种内部类都写在一起了，如下

public class InnerClass {
    public String st1;
    protected String st2;
    int a;
    private int b;
    private static int c;
    //普通内部类
    public class InnerClass1{

        public void say(){
            //可以使用外部类的所有属性
            System.out.println("普通内部类");
            System.out.println(st1+st2+a+b);
        }
    }
    //静态内部类
    public static class InnerClass2{
        public void say(){
            //只能访问外部类的所有静态属性
            System.out.println("静态内部类");
            System.out.println(c);
        }
    }
    //局部内部类
    public void say(){
        int i=0;
        final int j=1;
        class InnerClass3{
            //能使用外部类中所有的属性,
            //能访问，但是不能修改方法中的局部变量的值
            public void say(){
                System.out.println("局部内部类");
                System.out.println(a+i+j);
            }
        }
        InnerClass3 innerClass3 = new InnerClass3();
        innerClass3.say();
    }
    //匿名内部类
    public void say1(){
        //匿名内部类（实现接口）
        NiMingInterface nmi = new NiMingInterface(){

            @Override
            public void say() {
                System.out.println("匿名内部类:实现接口");
            }
        };
        nmi.say();
        //匿名内部类（继承抽象类）
        NiMingClass nmc = new NiMingClass(){

            @Override
            public void say() {
                System.out.println("匿名内部类:继承抽象类");
            }
        };
        nmc.say();
    }


    public static void main(String[] args) {
        InnerClass inner = new InnerClass();
        //普通内部类
        //外部类名.内部类名 变量名 = 外部类对象.new 内部类名();
        InnerClass.InnerClass1 innerClass1 = inner.new InnerClass1();
        innerClass1.say();
        //静态内部类
        //外部类名.内部类名 变量名 = new 外部类名.内部类名();
        InnerClass.InnerClass2 innerClass2 = new InnerClass.InnerClass2();
        innerClass2.say();
        //局部内部类
        inner.say();
        //匿名内部类
        inner.say1();

    }

}

//用于匿名内部类实现接口
public interface NiMingInterface {
    public void say();
}

//用于匿名内部类继承抽象类
public abstract class NiMingClass {
    public abstract void say();
}

输出结果如图：

今天学习分享的内容到此为止了，本是想要激励自己学下去，但发现快乐更是知识在于分享！
作为初学者对于Java的理解实在浅薄，如有错误请指正，万分感谢！

本文地址：https://blog.csdn.net/qq_39012899/article/details/109635570