Java学习【抽象类和接口】

2的n次方

发布于 2024-10-15 15:16:19

5300

代码可运行

文章被收录于专栏：CSDN 迁移文章CSDN 迁移文章

运行总次数：0

代码可运行

抽象类

抽象类是一种不能被实例化的类，其中至少包含一个抽象方法（即没有实现体的方法）。抽象类通常用于定义一组相关的类的共同特征，并强制其子类实现特定的方法。

抽象方法

将共性的方法抽取到父类之后，由于每个子类执行的内容不一样，所以在父类中不能确定具体的方法体，这样的方法就可以定义成为抽象方法

定义格式： public abstract 返回值类型方法名（参数列表）;

public abstract void work();

抽象方法不能被static , final 修饰，抽象方法就是为了被重写的 匿名对象的方式调用抽象方法 前提已经写好了work的抽象方法和类的继承关系

public class Text {
    public static void working(Person p){
        p.work();
    }
    public static void main(String[] args) {
        
        Student student = new Student();
        working(student);
        working(student);

        //匿名对象的方式调用方法
        working(new Student());
        working(new Student());
    }
}

普通的调用一个对象可以多次调用方法，匿名对象的方法调用每次调用都创建了对象

抽象类

如果一个类中有抽象方法，这个类就必须声明成抽象类

定义格式: public abstract class 类名{}

public abstract class Person {

    public abstract void work();
}

注意： 1.抽象类不能实例化对象

2.抽象类中不一定有抽象方法，有抽象方法的类一定要设置成抽象类 3.抽象类可以有构造方法 4.抽象方法的子类要不重写父类的抽象方法，要不自身也是抽象类那可能就有疑问了，既然抽象类不能实例化对象，那么要构造方法有什么用

通过向上转型的方式创建一个子类对象，通过父类的构造方法初始化子类继承的属性

接口

接口是一个完全抽象的类，用来规范类的行为，

比如有以上的继承关系，根据fish,student,teacher的共性来定义swim的行为，此时swim并不存在任何继承的关系，就可以把它定义为一个接口去被fish,student,teacher实现

接口的实现

1.接口使用关键字interface来定义 public interface 接口名{ } 2.接口不能实例化 3.接口和类是实现关系，通过关键字implements表示 public class 类名 implements 接口名{} 4.接口的子类要么重写接口中所有的抽象方法，要么是抽象类 5.接口和类之间可以单实现，也可以多实现，接口的出现，弥补了Java不能多继承的缺陷

接口中的成员变量默认是public static final修饰的，用static修饰调用方便，接口名.方法名调用，用》>final修饰，不可更改，所以也说明了接口中定义的是一种规范接口中的方法是public abstract修饰的所以说接口的实现类在重写接口的方法时只能用public修饰接口中不能有代码块和构造方法

如果方法是被default和static修饰的可以有具体的实现

以下就是接口的实现例子：

实现多个接口

以下分别定义好了两个接口

public interface IRun {
    void run();
}

public interface ISwim {
    void swim();
}

Dog类继承Animal类之后再实现两个接口

public class Dog extends Animal implements ISwim,IRun{
	 public Dog() {
        super();
    }
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void run(){
        System.out.println(this.name + "在跑");
    }
    @Override
    public void swim() {
        System.out.println(this.name + "在游泳");
    }
}

测试类实现：

public class Text {
    public static void main(String[] args) {
        running(new Dog("大黄", 3));
        swimming(new Dog("大黄", 3));
    }

    public static void running(IRun iRun){
        iRun.run();
    }
    public static void swimming(ISwim iSwim){
        iSwim.swim();
    }
}

接口与接口的关系

接口和接口之间是继承的关系，可以单继承也可以多继承

interface Ia{
    void showA();
}
interface Ib{
    void showB();
}
interface Ic extends Ia,Ib{
    void showC();
}
class D implements Ic{

    @Override
    public void showA() {
        
    }

    @Override
    public void showB() {

    }

    @Override
    public void showC() {

    }
}
public class Demo {
}

Ic继承了Ia,Ib，同时类D实现了Ic接口，此时Ia,Ib,Ic的方法都需要重写，所以，接口间的继承相当于把多个接口结合在一起

内部类

内部类其实就是一个类里边再定义一个类，表示是外部类的一部分访问特点：内部类可以直接访问外部类的成员，包括私有的外部类要访问内部类的成员，必须创建对象

public class Car {
    String carName;
    String carColor;
    //Car this可写可不写
    public void show(Car this){
        System.out.println(this.carName);
        //创建内部类的对象才能访问内部类成员变量
        Engine e = new Engine();
        System.out.println(e.engineName);
    }
    class Engine{
        String engineName;
        int engineAge;
        public void show(){
            //可以直接调用外部类成员变量
            System.out.println(engineName);
            System.out.println(engineAge);
        }
    }
}

成员内部类

成员内部类也就是写在成员位置的，属于外部类的成员，上面的代码就是一个成员内部类的例子，成员内部类可以被一些修饰符所修饰，例如private,默认，protexted,public,static等在JDK16版本之前，成员内部类里面不能定义静态变量，JDK16开始才可以定义静态变量 获取内部类成员对象： 1.在外部类中编写方法，对外提供内部类对象 2.直接创建格式：外部类名.内部类名对象名 = 外部对象.内部对象；

遇到重名时的访问：

public class Outer {
    String name;
    private int a = 10;
    class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
            System.out.println(Outer.this.a);//10
            System.out.println(this.a);//20
            System.out.println(a);//30
        }
    }

    //外部类编写获取内部类的方法
    public Inner getInnerInstance(){
        return new Inner();
    }
}

静态内部类

静态内部类其实就是在成员内部类的基础上加上static修饰之后，就变为了静态内部类，静态内部类只能访问外部类中的静态变量和静态方法，如果要想访问非静态的需要创建对象 1.创建静态内部类对象的格式：外部类名.内部类名对象名 = new 外部类名.内部类名（）； 2.调用非静态方法的格式：先创建对象，用对象调用； 3.调用静态方法的格式：外部类名.内部类名.方法名

修改为以下代码

public class Souter {
    int a;
    static int b;
    static class Inner{
        public void print(){
            Souter s = new Souter();
            System.out.println(s.a);
            System.out.println(b);
        }
    }
}

方法的调用：

public class Souter {
    int a;
    static int b;
    static class Inner{
        public void print(){
            Souter s = new Souter();
            System.out.println(s.a);
            System.out.println(b);
        }
        public static void show(){
            System.out.println("静态内部类");
        }
    }

    public static void main(String[] args) {
        //创建对象，对象名调用非静态方法
        Souter.Inner inner = new Souter.Inner();
        inner.print();
        //类名调用静态方法
        Souter.Inner.show();
    }
}

局部内部类

将内部类定义在方法里面就是局部内部类，类似于方法里面的局部变量 1.外界无法直接使用，需要在方法内部创建对象并使用 2.该类可以直接访问外部类的成员，也可以访问方法里的局部变量

public class Oouter {
    public void show(){
        int a;
        class Inner{
            String name;
            public void method1(){
                System.out.println("局部内部类方法");
            }
            public static void method2(){
                System.out.println("局部内部类静态方法");
            }
        }
        //创建对象访问局部内部类属性及方法
        Inner inner = new Inner();
        System.out.println(inner.name);
        inner.method1();
        //类名访问静态方法
        Inner.method2();
    }
}