java 抽象类创建对象吗 java抽象类怎么创建

转载

mob64ca14150f43 2023-08-19 19:15:37

文章标签 java 抽象类创建对象吗 java 抽象类抽象方法 System 文章分类 Java 后端开发

抽象类和接口

抽象类

抽象类概述
抽象类的特点
抽象类的成员特点

接口

接口概述
接口的特点
接口的成员特点
案例测试
类和接口的关系
抽象类和接口的区别

抽象类

抽象类概述

在java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

新建一个抽象类：

public abstract class Animal {
    public abstract void eat();
}

直接创建对象报错：

public class AnimalDemo {
    Animal a = new Animal();	//抽象类不能直接创建对象
    }
}

java 抽象类创建对象吗 java抽象类怎么创建_抽象方法

抽象类的特点

代码测试：

/*
   抽象类
*/
public abstract class Animal {
   //抽象方法 抽象类可以没有抽象方法
   public abstract void eat();
   //可以有非抽象方法
   public void sleep(){
       System.out.println("睡觉");
   }
}

/*
    抽象实现类
*/
public class Cat extends Animal{
   @Override		//必须重写抽象方法
   public void eat() {
       System.out.println("🐱吃🐟");
   }
}

public class AnimalDemo {
   public static void main(String[] args) {
       //Animal a = new Animal(); 抽象类不能创建对象
       Animal a = new Cat();   //抽象类创建对象需要用到多态
       a.eat();
       a.sleep();
   }
}

运行结果：

java 抽象类创建对象吗 java抽象类怎么创建_抽象类_02

抽象类和抽象方法必须使用bastract关键字修饰
public abstract class 类名{}
public abstract void eat();
抽象类中不一定有抽象方法。有抽象方法的雷一定是抽象类
抽象类不能直接实例化
抽象类能够参照多态的方式，通过子类对象实例化，这叫抽象类多态
抽象类的子类
要么重写抽象类的所有抽象方法
要么子类本身就是抽象类

抽象类的成员特点

代码测试：

/*
    抽象类
 */
public abstract class Animal {

    private int age = 20;       //抽象类可以定义成员变量
    private final String city = "成都";

    public Animal(){}           //抽象类不能直接实例化但还是有构造方法 用于子类访问父类数据的初始化

    public Animal(int age){     //抽象类可以创建带参构造方法
        this.age = age;
    }

    public void show() {        //抽象类可以创建方法
        age = 40;
        //city = "新都";
        System.out.println(age);
        System.out.println(city);
    }

    public abstract void eat();

}

public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("🐱吃🐟");
    }

}

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

运行结果：

java 抽象类创建对象吗 java抽象类怎么创建_抽象方法_03

特点：

可以有成员变量
可以是变量，也可以是常量
可以有构造方法但是不能实例化
作用是用于子类访问父类数据的初始化
可以有成员方法
可以有抽象方法：限定子类必须完成某些操作
也可以有非抽象方法：提高代码复用性

接口

接口概述

接口就是一种公共的规范标准，只要符合标准，大家都可以通用
Java中的接口更多体现在对行为的抽象

接口的特点

代码测试：

/*
    定义一个接口
 */
public interface Jumpping {         //接口用interface修饰

    public abstract void jump();    //定义抽象方法

}

/*
    接口实现类
 */
public class Cat implements Jumpping{           //类实现接口用implement关键字

    @Override
    public void jump() {                        //实现接口必须重写接口的抽象方法
        System.out.println("猫可以跳高");
    }
}

/*
    测试类
 */
public class JumppingDemo {
    public static void main(String[] args) {
        
        //Jumpping j = new Jumpping();              接口不能被直接实例化
        Jumpping cat = new Cat();                 //接口可以用多态的形式实现
        cat.jump();
    }
}

运行结果：

java 抽象类创建对象吗 java抽象类怎么创建_java 抽象类创建对象吗_04

代码测试：

public abstract class Dog implements Jumpping{          //抽象类在实现接口的时候不需要重写抽象方法

}

接口的特点：

接口用关键字interface修饰
public interface 接口名{}
类实现接口用implements表示
public class 类名 implements 接口名{}
接口不能实例化
接口需要参照堕胎的方式，通过实现类对象实例化，这叫接口堕胎
多态的形式：具体类多态、抽象多态、接口多态
多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向子（类/实现）对象
接口的实现类
要么重写接口中的所有抽象方法
要么是抽象类

接口的成员特点

代码测试：

public interface Inter {
    int num = 10;             //接口中的成员变量默认被public static final修饰
    public final int num2 = 20;

    //public Inter(){}          接口没有构造方法

    //public void show(){}      接口不能有非抽象的成员方法

    void show();              //接口中的成员方法默认被public abstract修饰

    public abstract void  method();
}

//public class InterImpl implements Inter{

public class InterImpl extends Object implements Inter  {      //如果没有继承默认继承Object

    public InterImpl(){
        super();                    //类中构造方法默认第一句为super();
    }                               //所以他不是调用Inter的构造方法，而是Object的构造方法

    @Override
    public void show() {
        System.out.println("show"); //可以重写没有abstract修饰的方法
    }

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

public class InterfaceDemo02 {
    public static void main(String[] args) {

        Inter i = new InterImpl();
        //i.num++;                          接口中的成员变量是常量,不能修改
        System.out.println(i.num);
        System.out.println(i.num2);

        System.out.println(Inter.num);      //可以通过接口直接访问常量
        System.out.println(Inter.num2);
    }
}

接口的成员特点

成员变量
只能是常量
默认修饰符：**public static final
构造方法
接口没有构造方法，因为接口主要是对行为的抽象，没有具体存在
一个类如果没有父类，默认继承自Object类
成员方法
只能是抽象方法
默认修饰符：public abstract

案例测试

需求：对猫和狗进行训练，他们就可以调高了，这里加入跳高功能。

代码：

public interface Jumpping {			//跳 动作接口
    public abstract void jump();
}

public abstract class Animal implements Jumpping{		//动物抽象类实现跳的动作
    public int height;

    @Override
    public abstract void jump();

}

public class Cat extends Animal{		//猫猫

    public Cat(int height) {
        this.height = height;
    }

    @Override
    public void jump() {
        System.out.println("🐱跳了"+this.height);
    }
}

public class Dog extends Animal{		//狗狗

    public Dog(int height){
        this.height=height;
    }

    @Override
    public void jump() {
        System.out.println("🐕跳了"+height);
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        Animal cat = new Cat(180);
        cat.jump();
        Animal dog = new Dog(110);
        dog.jump();
    }
}

运行结果：

java 抽象类创建对象吗 java抽象类怎么创建_System_05