Java14-抽象、接口、内部类

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量918 收藏 17
点赞数 24
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73902080/article/details/137728294
版权

抽象

概述

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类只需要提供一个没有方法体的定义即可，具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

abstract

abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。

抽象方法

使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；
public abstract void run()；

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。

注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

定义格式：

abstract class 类名字 { 
  
}
public abstract class Animal {
    public abstract void run()；
}

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。 

// 父类,抽象类
abstract class Employee {
	private String id;
	private String name;
	private double salary;
	
	public Employee() {
	}
	
	public Employee(String id, String name, double salary) {
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	// 抽象方法
	// 抽象方法必须要放在抽象类中
	abstract public void work();
}

// 定义一个子类继承抽象类
class Manager extends Employee {
	public Manager() {
	}
	public Manager(String id, String name, double salary) {
		super(id, name, salary);
	}
	// 2.重写父类的抽象方法
	@Override
	public void work() {
		System.out.println("管理其他人");
	}
}

// 定义一个子类继承抽象类
class Cook extends Employee {
	public Cook() {
	}
	public Cook(String id, String name, double salary) {
		super(id, name, salary);
	}
	@Override
	public void work() {
		System.out.println("厨师炒菜多加点盐...");
	}
}

// 测试类
public class Demo10 {
	public static void main(String[] args) {
		// 创建抽象类,抽象类不能创建对象
		// 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象
//		Employee e = new Employee();
//		e.work();
		
		// 3.创建子类
		Manager m = new Manager();
		m.work();
		
		Cook c = new Cook("ap002", "库克", 1);
		c.work();
	}
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

特征：

抽象类的特征总结起来可以说是【有得有失】

  • 有得：抽象类得到了拥有抽象方法的能力。
  • 有失：抽象类失去了创建对象的能力。

其他成员（构造方法，实例方法，静态方法等）抽象类都是具备的。

细节：

  1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

    理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

  2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

    理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

  3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

    理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

  4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。

    理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

  5. 抽象类存在的意义是为了被子类继承。

    理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

存在的意义：

抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义。抽象类可以强制让子类，一定要按照规定的格式进行重写。

接口

定义格式

//接口的定义格式：
interface 接口名称{
    // 抽象方法
}

// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

特点

在JDK7，包括JDK7之前，接口中的只有包含：抽象方法和常量

抽象方法

  • 注意：接口中的抽象方法默认会自动加上public abstract修饰，程序员无需自己手写！！ ​
  • 按照规范：以后接口中的抽象方法建议不要写上public abstract。

常量

  • 在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。
  • 这里是使用public static final修饰后，变量值就不可被修改，并且是静态化的变量。可以直接用接口名访问，所以也叫常量。
  • 常量必须要给初始值。常量命名规范建议字母全部大写，多个单词用下划线连接。
public interface InterF {
    // 抽象方法！
    //    public abstract void run();
    void run();

    //    public abstract String getName();
    String getName();

    //    public abstract int add(int a , int b);
    int add(int a , int b);


    // 它的最终写法是：
    // public static final int AGE = 12 ;
    int AGE  = 12; //常量
    String SCHOOL_NAME = "张三";

}

实现

概述

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

格式

/**接口的实现：
    在Java中接口是被实现的，实现接口的类称为实现类。
    实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{

}

类与接口的关系

类与接口单实现案例

假如我们定义一个运动员的接口（规范），代码如下：

/**
   接口：接口体现的是规范。
 * */
public interface SportMan {
    void run(); // 抽象方法，跑步。
    void law(); // 抽象方法，遵守法律。
    String compittion(String project);  // 抽象方法，比赛。
}

接下来定义一个乒乓球运动员类，实现接口，实现接口的实现类代码如下：

package com.itheima._03接口的实现;
/**
 * 接口的实现：
 *    在Java中接口是被实现的，实现接口的类称为实现类。
 *    实现类的格式:
 *      class 类名 implements 接口1,接口2,接口3...{
 *
 *
 *      }
 * */
public class PingPongMan  implements SportMan {
    @Override
    public void run() {
        System.out.println("乒乓球运动员稍微跑一下！！");
    }

    @Override
    public void law() {
        System.out.println("乒乓球运动员守法！");
    }

    @Override
    public String compittion(String project) {
        return "参加"+project+"得金牌！";
    }
}

测试代码：

public class TestMain {
    public static void main(String[] args) {
        // 创建实现类对象。
        PingPongMan zjk = new PingPongMan();
        zjk.run();
        zjk.law();
        System.out.println(zjk.compittion("全球乒乓球比赛"));

    }
}
类与接口多实现案例

类与接口之间的关系是多实现的，一个类可以同时实现多个接口。

/** 法律规范：接口*/
public interface Law {
    void rule();
}

/** 这一个运动员的规范：接口*/
public interface SportMan {
    void run();
}

/**
 * Java中接口是可以被多实现的：
 *    一个类可以实现多个接口: Law, SportMan
 *
 * */
public class JumpMan implements Law ,SportMan {
    @Override
    public void rule() {
        System.out.println("尊长守法");
    }

    @Override
    public void run() {
        System.out.println("训练跑步！");
    }
}
接口与接口的多继承

Java中，接口与接口之间是可以多继承的：也就是一个接口可以同时继承多个接口。

注意：接口继承接口就是把其他接口的抽象方法与本接口进行了合并

public interface Abc {
    void go();
    void test();
}

/** 法律规范：接口*/
public interface Law {
    void rule();
    void test();
}

 *
 *  总结：
 *     接口与类之间是多实现的。
 *     接口与接口之间是多继承的。
 * */
public interface SportMan extends Law , Abc {
    void run();
}

细节

1.当两个接口中存在相同抽象方法的时候，该怎么办？

只要重写一次即可。此时重写的方法，既表示重写1接口的，也表示重写2接口的。

2.实现类能不能继承A类的时候，同时实现其他接口呢？

继承的父类，就好比是亲爸爸一样 实现的接口，就好比是干爹一样 可以继承一个类的同时，再实现多个接口，只不过，要把接口里面所有的抽象方法，全部实现。

3.实现类能不能继承一个抽象类的时候，同时实现其他接口呢？

实现类可以继承一个抽象类的同时，再实现其他多个接口，只不过要把里面所有的抽象方法全部重写。

4.实现类Zi，实现了一个接口，还继承了一个Fu类。假设在接口中有一个方法，父类中也有一个相同的方法。子类如何操作呢？

处理办法一：如果父类中的方法体，能满足当前业务的需求，在子类中可以不用重写。 处理办法二：如果父类中的方法体，不能满足当前业务的需求，需要在子类中重写。

5.如果一个接口中，有10个抽象方法，但是我在实现类中，只需要用其中一个，该怎么办?

可以在接口跟实现类中间，新建一个中间类（适配器类） 让这个适配器类去实现接口，对接口里面的所有的方法做空重写。 让子类继承这个适配器类，想要用到哪个方法，就重写哪个方法。 因为中间类没有什么实际的意义，所以一般会把中间类定义为抽象的，不让外界创建对象

内部类

概述

什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。

什么时候使用内部类

一个事物内部还有一个独立的事物，内部的事物脱离外部的事物无法独立使用。

  1. 人里面有一颗心脏。

  2. 汽车内部有一个发动机。

  3. 为了实现更好的封装性。

内部类的分类

按定义的位置来分

  1. 成员内部类，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)

  2. 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)

  3. 局部内部类，类定义在方法内

  4. 匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。

成员内部类

特点：

  • 无static修饰的内部类，属于外部类对象的。

  • 宿主：外部类对象。

使用格式：

方式一：外部直接创建成员内部类的对象

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

方式二：在外部类中定义一个方法提供内部类的对象

方式一：
public class Test {
    public static void main(String[] args) {
        //  宿主：外部类对象。
       // Outer out = new Outer();
        // 创建内部类对象。
        Outer.Inner oi = new Outer().new Inner();
        oi.method();
    }
}

class Outer {
    // 成员内部类，属于外部类对象的。
    // 拓展：成员内部类不能定义静态成员。
    public class Inner{
        // 这里面的东西与类是完全一样的。
        public void method(){
            System.out.println("内部类中的方法被调用了");
        }
    }
}


方式二：
public class Outer {
    String name;
    private class Inner{
        static int a = 10;
    }
    public Inner getInstance(){
        return new Inner();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        System.out.println(o.getInstance());


    }
}
细节

编写成员内部类的注意点：

  • 成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
  • 在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。
  • 创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。

详解：

  • 内部类被private修饰，外界无法直接获取内部类的对象，只能通过方式二获取内部类的对象
  • 被其他权限修饰符修饰的内部类一般用3.3节中的方式一直接获取内部类的对象
  • 内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类。
  • 内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。
例题

请在?地方向上相应代码,以达到输出的内容

注意：内部类访问外部类对象的格式是：外部类名.this

public class Test {
    public static void main(String[] args) {
        Outer.inner oi = new Outer().new inner();
        oi.method();
    }
}

class Outer {	// 外部类
    private int a = 30;

    // 在成员位置定义一个类
    class inner {
        private int a = 20;

        public void method() {
            int a = 10;
            System.out.println(???);	// 10   答案：a
            System.out.println(???);	// 20	答案：this.a
            System.out.println(???);	// 30	答案：Outer.this.a
        }
    }
}
成员内部类内存图

静态内部类

特点

  • 静态内部类是一种特殊的成员内部类。

  • 有static修饰，属于外部类本身的。

  • 总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。

  • 拓展1:静态内部类可以直接访问外部类的静态成员。

  • 拓展2:静态内部类不可以直接访问外部类的非静态成员，如果要访问需要创建外部类的对象。

  • 拓展3:静态内部类中没有银行的Outer.this。

使用格式:外部类.内部类
对象的创建格式：外部类.内部类  变量 = new  外部类.内部类构造器;
调用方法的格式：

  • 调用非静态方法的格式：先创建对象，用对象调用

  • 调用静态方法的格式：外部类名.内部类名.方法名();

// 外部类：Outer01
class Outer01{
    private static  String sc_name = "黑马程序";
    // 内部类: Inner01
    public static class Inner01{
        // 这里面的东西与类是完全一样的。
        private String name;
        public Inner01(String name) {
            this.name = name;
        }
        public void showName(){
            System.out.println(this.name);
            // 拓展:静态内部类可以直接访问外部类的静态成员。
            System.out.println(sc_name);
        }
    }
}

public class InnerClassDemo01 {
    public static void main(String[] args) {
        // 创建静态内部类对象。
        // 外部类.内部类  变量 = new  外部类.内部类构造器;
        Outer01.Inner01 in  = new Outer01.Inner01("张三");
        in.showName();
    }
}

局部内部类

概述：定义在方法中的类。
定义格式：
class 外部类名 {
	数据类型 变量名;
	
	修饰符 返回值类型 方法名(参数列表) {
		// …
		class 内部类 {
			// 成员变量
			// 成员方法
		}
	}
}

匿名内部类【重点】

概述

匿名内部类 ：是内部类的简化写法。他是一个隐含了名字的内部类。开发中，最常用到的内部类就是匿名内部类。

格式：
new 类名或者接口名() {
     重写方法;
};

包含了：

  • 继承或者实现关系

  • 方法重写

  • 创建对象

所以从语法上来讲，这个整体其实是匿名内部类对象

什么时候使用匿名内部类

实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码。

之前我们使用接口时，似乎得做如下几步操作：

  1. 定义子类

  2. 重写接口中的方法

  3. 创建子类对象

  4. 调用重写后的方法

interface Swim {
    public abstract void swimming();
}

// 1. 定义接口的实现类
class Student implements Swim {
    // 2. 重写抽象方法
    @Override
    public void swimming() {
        System.out.println("狗刨式...");
    }
}

public class Test {
    public static void main(String[] args) {
        // 3. 创建实现类对象
        Student s = new Student();
        // 4. 调用方法
        s.swimming();
    }
}

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提

匿名内部类必须继承一个父类或者实现一个父接口。

以接口为例：

interface Swim {
    public abstract void swimming();
}

public class Demo07 {
    public static void main(String[] args) {
        // 使用匿名内部类
		new Swim() {
			@Override
			public void swimming() {
				System.out.println("自由泳...");
			}
		}.swimming();

        // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };

        s2.swimming();
        s2.swimming();
    }
}
特点

  1. 定义一个没有名字的内部类

  2. 这个类实现了父类，或者父类接口

  3. 匿名内部类会创建这个没有名字的类的对象

使用场景

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递

interface Swim {
    public abstract void swimming();
}

public class Demo07 {
    public static void main(String[] args) {
        // 普通方式传入对象
        // 创建实现类对象
        Student s = new Student();
        
        goSwimming(s);
        // 匿名内部类使用场景:作为方法参数传递
        Swim s3 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蝶泳...");
            }
        };
        // 传入匿名内部类
        goSwimming(s3);

        // 完美方案: 一步到位
        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("大学生, 蛙泳...");
            }
        });

        goSwimming(new Swim() {
            public void swimming() {
                System.out.println("小学生, 自由泳...");
            }
        });
    }

    // 定义一个方法,模拟请一些人去游泳
    public static void goSwimming(Swim s) {
        s.swimming();
    }
}

Onlooker129
关注
  • 24
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
03-java接口与内部类1
08-04
第 3 章 接口与内部类接口是什么？接口有什么作用？如何使用接口？这些都是本章需要解决的问题。本章将详细地讲述接口的概念，并以实战结合的方式，学习这些抽象概念。
day15-笔记-抽象类、接口、内部类
m0_51681861的博客
11-23 86
​ 父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类只需要提供一个没有方法体的定义即可，具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。抽象方法： 没有方法体的方法。抽象类：包含抽象方法的类。
java基础继承1----子类、父类(超类)
pan_nworld的博客
08-17 264
public class Manager extends Employee(){ //奖金 private double bouns; ....... public void setBouns(double bouns){ this.bouns = bouns; } } ​ 关键字extends代表继承，表明构造一个新类派生于一个已经存在的类。代码表示Manager类继承Employee类，Manager类称为子类，Employee称为父类。 .
异常Java
HongYu012的博客
02-24 827
异常 1.什么是异常 异常指程序运行过程中出现的不期而至的各种状况，如：文件找不到、网络连接失败等 异常发生在程序运行期间，它影响了正常的程序执行流程 public class Demo01 { public static void main(String[] args) { System.out.println(11/0); } } Exception in thread "main" java.lang.ArithmeticException: / by
Java-黑马Java学习作业-day15面向对象进阶（抽象类&接口&内部类）
Kox_233的博客
02-02 1382
抽象类；接口；内部类
Java---抽象类与接口
X_H学Java的博客
10-26 5613
一. 抽象类 1.1 抽象类的概念 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。例如： 说明： 1.Animal类是动物类，每个动物都有叫的方法，但是Animal不是一个具体的动物，因此其内部的bark()方法无法具体实现。 2.Dog是狗类继承Animal类，狗是一个具体的动物，狗叫“旺旺”，其bark()可以实现。 3.Cat是猫类继承Animal类，猫是一个具体的动
Java的接口、内部类、常用类
12-22
JAVA接口、内部类、常用类 一、JAVA接口 1.1 什么是接口？: 接口相当于特殊的抽象类，定义方式、组成部分于抽象类类似。 微观概念:接口是一种能力和约定 接口的定义:代表了某种能力 方法的定义:能力的具体要求 经验:...
java学习资料抽象类,接口,内部类
08-03
学习java技术的基础方面的知识,有利于更加好的理解 ,抽象类,接口,内部类
JAVA抽象类、接口和内部类（下）.mp4
04-11
JAVA抽象类、接口和内部类（下）.mp4
JAVA抽象类、接口和内部类（上）.mp4
04-11
JAVA抽象类、接口和内部类（上）.mp4
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 912
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 875
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 273
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Lambda表达式特点
weixin_57763462的博客
04-24 778
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 390
待更新。
Mybatis-动态SQL
weixin_43866613的博客
04-24 847
Mybatis的xml映射文件，以及动态SQL的应用
Java | 冒泡排序算法实现
yingzix688的博客
04-24 864
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
qq_43209531的博客
04-30 126
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 704
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
java中抽象类的作用
02-16
在Java中，抽象类是一种特殊的类，它不能被实例化，只能被继承。抽象类用于定义一组相关的类的通用行为和属性，它可以包含抽象方法和非抽象方法。 抽象类的作用主要有以下几点： 1. 定义通用行为：抽象类可以定义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值