第二篇Java基础知识的复习笔记

最新推荐文章于 2024-08-23 15:54:50 发布

Shion_online

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量110

点赞数 2

文章标签： java 学习

本文链接：https://blog.csdn.net/Sion_one/article/details/130311875

版权

第二篇Java基础知识的复习笔记

一、第六章（类和对象）概述

1.面向对象概述

Java 是一门面向对象的编程语言，其核心思想是面向对象编程（Object-Oriented Programming，简称 OOP）。面向对象编程是一种编程思想，它强调在程序设计中，应该把对象作为程序的基本单元来进行设计、实现和维护。

1.1对象

在 Java 中，一切都是对象。每个对象都有自己的状态和行为。状态指的是对象的属性或成员变量，而行为指的是对象的方法或成员函数。通过将属性和方法封装在对象中，可以实现对数据和功能的封装，从而提高代码的可维护性、复用性和安全性。

1.2类

类是面向对象编程的基本单位，是一种封装了数据和方法的代码模板。通过定义类，可以创建出具有相同属性和方法的对象。每个类都包含以下几个部分：

类名：类名是唯一的标识符，用于区分不同的类。
成员变量：类中的成员变量是用来描述对象状态的数据元素，也称为属性或字段。成员变量可以是基本数据类型，也可以是引用类型。
成员方法：类中的成员方法用于描述对象的行为和功能，也称为函数或方法。成员方法可以访问成员变量，并且可以接受参数和返回值。
构造方法：类中的构造方法用于创建对象，并且可以初始化对象的成员变量。构造方法的名称必须与类名相同，没有返回值类型，并且可以重载。

1.3封装

封装（Encapsulation）：将对象的属性和方法封装在一起，防止外部直接访问和修改对象的内部状态。通过提供公共的方法来让外部访问和操作对象的状态，从而实现数据的安全性和高内聚性。

1.4继承

继承（Inheritance）：通过继承来复用已有类的代码，从而实现代码的重用性和扩展性。子类可以继承父类的属性和方法，并可以在其基础上添加新的属性和方法。在 Java 中，类的继承通过 extends 关键字实现。

1.5多态

多态（Polymorphism）：同一个方法可以有多种不同的实现方式，可以根据对象的类型来动态地调用不同的方法。在 Java 中，多态可以通过方法重载（Overloading）和方法重写（Overriding）来实现。

2.类

2.1成员变量

成员变量也称为属性或字段，是类中用来描述对象状态的数据元素。每个对象都有一份独立的成员变量，它们的值可以在对象创建后通过成员方法进行访问和修改。

2.2成员方法

成员方法是Java中定义在类中的函数，它们用于定义类的行为和操作。每个对象都有自己的一份成员方法，它们可以访问和操作对象的属性，并执行一些操作。

成员方法有以下特点：

成员方法是定义在类中的函数，必须通过类的实例来调用。
成员方法可以访问对象的成员变量和其他成员方法。
成员方法可以有参数和返回值，也可以没有参数和返回值。
成员方法可以是静态的，也可以是非静态的。非静态成员方法必须通过对象来调用，而静态成员方法可以通过类名直接调用。
成员方法可以被重载，即可以定义多个同名但参数列表不同的方法。

通过成员方法，我们可以对对象进行各种操作，比如修改对象的属性，执行某些操作，返回某些结果等。成员方法的使用是面向对象编程的重要特征之一，可以大大提高代码的复用性和可维护性。

2.3权限修饰符

权限修饰符用于限制类、变量和方法的访问权限。Java中有四个权限修饰符：public、protected、default、private。

public：公共的，可以被任何类访问。在同一包或不同包的任何地方都可以被调用。
protected：受保护的，可以被本类、同一包和子类访问。在同一包的任何地方都可以被调用，在不同包的子类中也可以被调用。
default：默认的，如果没有使用任何权限修饰符，则默认为default。可以被本类、同一包的其他类访问，在不同包的类中不可以被访问。
private：私有的，只能被本类访问。在同一包或不同包的其他类中都不可以被调用。

2.4局部变量

局部变量是在方法、代码块或构造方法中定义的变量，只在定义它们的范围内可见。局部变量必须先声明并初始化，才能在代码块中使用。

2.5局部变量的有效范围

局部变量的有效范围（作用域）是在声明它的块（代码块或方法）内。局部变量在声明后必须先初始化，才能被使用，且只能在初始化后和声明块内部使用。

以下示例展示了 Java 中局部变量的有效范围：

csharpCopy codepublic class LocalVariables {
    public void test() {
        int a = 1; // 在方法内部定义的局部变量 a
        if (a == 1) { // 一个花括号代码块
            int b = 2; // 在代码块内定义的局部变量 b
            System.out.println("a = " + a + ", b = " + b);
            int a = 3; // 在代码块内定义的局部变量 a，会隐藏外部的局部变量 a
            System.out.println("a = " + a + ", b = " + b);
        }
        System.out.println("a = " + a); // 外部的局部变量 a 仍然可见
        // System.out.println("b = " + b); // 错误：b 未定义
    }
}

在上面的代码中，test() 方法内部定义了一个局部变量 a，然后在一个 if 语句的代码块内定义了一个局部变量 b。在这个代码块内，又定义了一个同名的局部变量 a，它隐藏了外部的局部变量 a。当程序运行到最后一个输出语句时，外部的局部变量 a 仍然是可见的，而内部的局部变量 a 和 b 已经超出了它们的作用域，不能再被访问。

2.6 ‘this’ 关键词

this 是一个关键字，表示当前对象的引用。它可以用来引用当前类的成员变量、成员方法、构造方法等。

具体来说，this 可以用来实现以下功能：

引用当前对象的成员变量：在一个类的成员方法中，如果该方法中的局部变量和成员变量同名，那么就需要使用 this 关键字来引用该成员变量，以区分局部变量和成员变量。例如：
```
typescriptCopy codepublic class Person {
    private String name; // 成员变量 name
    
    public void setName(String name) {
        this.name = name; // 使用 this 关键字引用成员变量
    }
}
```

调用当前对象的成员方法：在一个类的成员方法中，如果该方法需要调用该类的其他成员方法，那么就可以使用 this 关键字来引用当前对象，并调用该对象的成员方法。例如：

typescriptCopy codepublic class Person {
    private String name;
    
    public void setName(String name) {
        this.name = name; // 使用 this 关键字引用成员变量
    }
    
    public void printName() {
        System.out.println(this.getName()); // 使用 this 关键字调用成员方法
    }
    
    private String getName() { // 私有成员方法
        return this.name;
    }
}

在构造方法中调用其他构造方法：在一个类中，可以定义多个构造方法，其中一个构造方法可以调用另一个构造方法来完成一些公共的初始化工作。在这种情况下，需要使用 this 关键字来调用另一个构造方法，但是调用语句必须放在构造方法的第一行。例如：
```
arduinoCopy codepublic class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public Person(String name) {
        this(name, 0); // 调用另一个构造方法
    }
}
```

总之，this 关键字可以让程序员更方便地引用当前对象，并访问对象的成员变量和成员方法。

3.类的构造方法

构造方法是一种特殊的方法，用于创建对象时进行初始化操作。每个类可以有一个或多个构造方法，构造方法与类名相同，没有返回值类型，可以有参数列表。当创建类的实例时，会调用该类的构造方法来进行初始化。

构造方法的特点：

构造方法名必须与类名相同。
构造方法没有返回类型，包括 void。
如果一个类没有定义任何构造方法，那么编译器会自动生成一个默认构造方法，不带任何参数，仅执行一个空的操作。
如果一个类定义了有参构造方法，那么默认构造方法就不会自动生成了。如果需要同时支持有参构造方法和默认构造方法，就需要在类中显式地定义一个无参构造方法。
如果一个类需要进行一些特殊的初始化操作，例如对成员变量赋初值等，就需要定义自己的构造方法。

4.静态变量与静态方法

静态变量和静态方法是属于类的，而不是属于类的实例化对象的。它们在内存中只有一份，无论创建了多少个类的实例，都共享同一份静态变量和静态方法。在 Java 中，可以使用关键字 static 来定义静态变量和静态方法。

静态变量（也称为类变量）用 static 关键字修饰，在类中所有实例共享同一份变量，可以通过类名直接访问，无需创建类的实例。静态变量通常用于存储与类相关的常量值、计数器等，而不是每个实例独立保存的数据。静态变量可以在类加载时初始化，也可以在静态代码块中进行初始化。

静态方法也使用 static 关键字修饰，与静态变量一样，属于类而不是对象。静态方法不依赖于任何对象实例，可以直接通过类名调用，不能访问非静态变量或非静态方法（因为非静态变量和方法是属于对象实例的）。静态方法通常用于工具类、工厂方法、数学计算等，不涉及到对象实例的操作。

5.类的主方法

Java 中的主方法（main 方法）是一个程序的入口点，是程序开始执行的地方。主方法必须定义为 public、static 和 void 类型，且必须接受一个 String 类型的数组参数。主方法的语法如下：

javaCopy codepublic static void main(String[] args) {
    // 程序的主体部分
}

其中，public 表示主方法是公共的，可以被其他类访问；static 表示主方法是静态的，可以在没有类实例的情况下调用；void 表示主方法没有返回值；String[] args 表示主方法接受一个字符串数组类型的参数，用于传递命令行参数。

当程序执行时，JVM 会自动调用 main 方法，并将命令行参数传递给它。可以通过 args 数组来访问命令行参数。如果不需要传递命令行参数，则可以省略 args 参数。

下面是一个简单的示例：

javaCopy codepublic class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

在上面的示例中，HelloWorld 类包含一个 main 方法，输出了一条简单的消息。当执行这个程序时，JVM 会自动调用 main 方法，并输出 “Hello, world!”。注意，命令行参数可以在运行时传递给程序，例如：

Copy code
java HelloWorld arg1 arg2

在上面的命令中，HelloWorld 是要运行的类名，arg1 和 arg2 是命令行参数。这些参数将被传递给 main 方法的 args 数组。

6.对象

6.1对象的创建

在 Java 中，要创建一个对象，通常需要经过以下三个步骤：

1.定义一个类

对象是类的一个实例，因此要创建对象，首先需要定义一个类，即描述对象的属性和方法。类定义了一类对象的通用行为和特征，可以看作是对象的模板。

类的定义一般包括类名、成员变量、构造方法和成员方法等。例如：

javaCopy codepublic class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", and I am " + age + " years old.");
    }
}

上述代码定义了一个 Person 类，包括两个成员变量 name 和 age，一个构造方法和一个成员方法 sayHello()。

2.创建对象

创建对象需要使用 new 关键字和构造方法。构造方法用于初始化对象的属性和状态信息。

javaCopy code
Person person = new Person("Tom", 20);

上述代码使用 new 关键字创建了一个 Person 对象，通过构造方法初始化了对象的 name 和 age 属性。同时，使用 person 引用来指向这个对象。

3.访问对象

创建对象后，就可以使用对象的引用来访问对象的属性和方法。例如：

javaCopy codeSystem.out.println(person.name); // 输出 "Tom"
System.out.println(person.age); // 输出 20
person.sayHello(); // 输出 "Hello, my name is Tom, and I am 20 years old."

上述代码通过对象的引用 person 来访问对象的属性和方法。可以在任何需要引用对象的地方使用对象的引用来操作对象的属性和方法。

6.2访问对象的属性和行为

在 Java 中，可以通过对象的引用来访问对象的属性和行为。

1.访问对象的属性：

对象的属性也称为实例变量，可以使用点号操作符 . 来访问。例如，如果有一个 Person 类，其中定义了一个 name 属性，可以通过对象的引用来访问该属性：

javaCopy codePerson person = new Person("Tom");
String name = person.name;

上述代码创建了一个 Person 对象 person，并使用对象的引用 person 来访问对象的 name 属性，并将属性值赋值给变量 name。

2.访问对象的行为：

对象的行为也称为实例方法，同样可以使用点号操作符 . 来访问。例如，如果有一个 Person 类，其中定义了一个 sayHello() 方法，可以通过对象的引用来调用该方法：

javaCopy codePerson person = new Person("Tom");
person.sayHello();

上述代码创建了一个 Person 对象 person，并使用对象的引用 person 来调用对象的 sayHello() 方法。

需要注意的是，访问对象的属性和行为都必须通过对象的引用来进行，否则编译器会报错。如果没有引用，就无法访问该对象的属性和行为。例如，下面的代码会报错：

javaCopy codeString name = person.name; // 编译错误，无法访问对象的属性
person.sayHello(); // 编译错误，无法访问对象的行为

6.3对象的引用

对象的引用是指用于访问对象的变量。可以将对象的引用看作是指向对象内存地址的指针，通过它可以访问对象的属性和行为。

创建对象时，需要使用 new 关键字来分配内存，并返回对该对象的引用。例如，创建一个 Person 对象，并将其引用存储在 person 变量中：

javaCopy code
Person person = new Person();

上述代码创建了一个 Person 对象，并将该对象的引用存储在 person 变量中。此时，可以通过 person 变量来访问该对象的属性和行为。

6.4对象的销毁

对象的销毁是由垃圾回收器（Garbage Collector）负责的，而不是由程序员手动控制。垃圾回收器会定期扫描内存中的对象，找出那些没有被引用的对象，并释放它们占用的内存空间。

一个对象被销毁的条件是，它没有被任何引用变量引用。当一个对象不再被引用时，它就成为了垃圾，等待垃圾回收器回收。垃圾回收器会在适当的时候（例如内存不足时）启动，并回收那些没有被引用的对象所占用的内存空间。

二、第七章（继承、多态、抽象类与接口）概述

继承和多态性经常一起使用。通过继承，子类可以继承父类的属性和方法，并且可以重写这些方法来实现自己的功能。而通过多态性，可以在父类中定义一个方法，让所有的子类都去实现这个方法，从而实现不同子类的不同行为。这样可以让代码更加灵活、可扩展和易维护。

1.类的继承

继承是一种面向对象编程的概念，它允许一个类继承另一个类的属性和方法。被继承的类称为父类或基类，继承的类称为子类或派生类。子类可以继承父类中所有可见的属性和方法，包括公共、受保护和默认级别的成员变量和方法，但不包括私有成员变量和方法。

Java虽然不允许同时继承两个父类，但不代表没有多继承的关系，可以通过类似“祖父>父>儿子>孙子”的方式实现多代继承。

例：绝大多数动物有眼睛，鼻子和嘴，犬类继承动物类，所以犬类也有眼睛，鼻子和嘴，哈士奇是犬类的一个品种，犬类有的特征哈士奇都有，但哈士奇的眼睛鼻子和嘴并不是从犬类继承的，而是从动物类继承的。

class Animal {                //父类：动物类
    Eyes eyes;
    Nose nose;
    Mouth mouth;
}

class Dog extends Animal{}    //子类：犬类
class Husky extends Dog{}     //子类：哈士奇类

2.Object类

Java中所有的类都是直接或间接继承自Object类。Object类是Java中的基类，它提供了一些常用的方法和属性，可以被其他所有的类继承和使用。

2.1、getClass()方法

getClass()方法：用于获取对象的类对象。可以使用getClass()方法来获取对象的类名、访问类的属性和方法等信息。

语法如下：

getClass().getName();

getClass()方法与toString()方法可以联合使用。

2.2、toString()方法

toString()方法：用于将对象转换为字符串表示。默认情况下，toString()方法返回对象的类名和内存地址，但可以被子类重写来实现自定义的字符串表示。

2.3、equals()方法

equals()方法：用于比较两个对象是否相等。默认情况下，equals()方法比较的是两个对象的引用是否相等，但可以被子类重写来实现自定义的相等比较。

3.对象类型转换

Java中，对象类型的转换包括向上转型和向下转型两种类型。

3.1 向上转型

向上转型是指将子类对象转换成父类对象的过程。这种转换是自动完成的，无需任何显式的类型转换操作。由于子类继承了父类的属性和方法，因此可以将子类对象看作是父类对象的一种特殊形式，从而可以将子类对象赋值给父类对象。

例，假设有一个Animal类和一个Cat类，Cat类是Animal类的子类。可以使用如下的代码进行向上转型：

javaCopy code
Animal animal = new Cat();

在这个例子中，创建了一个Cat对象，并将其赋值给Animal类型的引用变量animal。由于Cat类是Animal类的子类，因此可以将Cat对象向上转型成Animal对象。

3.2向下转型

向下转型是指将父类对象转换成子类对象的过程。这种转换需要显式的类型转换操作，并且需要确保父类对象实际上是子类对象的实例。如果转换不正确，则会引发ClassCastException异常。

例，假设有一个Animal类和一个Cat类，可以使用如下的代码进行向下转型：

javaCopy codeAnimal animal = new Cat();
Cat cat = (Cat)animal;

在这个例子中，首先将一个Cat对象向上转型成Animal对象，并将其赋值给一个Animal类型的引用变量animal。然后，将animal对象向下转型成Cat对象，并将其赋值给一个Cat类型的引用变量cat。由于animal对象实际上是Cat对象的实例，因此可以将其向下转型成Cat对象。

需要注意，在进行向下转型时需要确保父类对象实际上是子类对象的实例。可以使用instanceof运算符来检查对象的类型，从而避免ClassCastException异常的发生。

4.使用instanceof关键字判断对象类型

instanceof关键字是用于检查对象的类型。它的语法格式为：

javaCopy code
对象 instanceof 类名

其中，对象是要检查的对象，类名是要检查的类名或接口名。如果对象是该类或接口的一个实例，则返回true；否则返回false。

instanceof可以用来检查对象的类型，从而避免进行不正确的类型转换。例如，假设有一个Animal类和一个Cat类，可以使用如下的代码进行类型检查：

javaCopy codeAnimal animal = new Cat();
if (animal instanceof Cat) {
    Cat cat = (Cat)animal;
    // 执行 Cat 类型的操作
} else {
    // 处理 Animal 类型的情况
}

在这个例子中，首先将一个Cat对象向上转型成Animal对象，并将其赋值给一个Animal类型的引用变量animal。然后，使用instanceof检查animal对象是否是Cat类型的实例，如果是，则将其向下转型成Cat对象，并执行Cat类型的操作；否则，处理Animal类型的情况。

需要注意，instanceof只能用来检查对象的类型，不能用来检查基本类型。例如，不能使用instanceof来检查int类型的变量。此外，instanceof也不能用来检查对象的泛型类型。

5.方法的重载

方法的重载（Overloading）是指在同一个类中可以定义多个方法名相同但参数类型、个数或顺序不同的方法。重载方法可以让程序代码更加简洁、清晰，并且可以根据不同的参数类型、个数和顺序进行不同的处理。

方法的重载需要满足以下两个条件：

1.方法名相同

2.参数列表不同，包括参数类型、个数或顺序不同

注意：返回值类型不是方法的重载条件。

例，下面就是一个计算两个整数之和的重载方法：

public int sum(int a, int b) {
    return a + b;
}
public int sum(int a, int b, int c) {
    return a + b + c;
}
public int sum(double a, double b) {
    return (int)(a + b);
}

上面的三个方法都是sum，但是它们的参数列表不同，所以它们是不同的方法。我们可以根据参数的不同类型、个数或顺序调用不同的方法，实现相应的功能。例如：

int result1 = sum(1, 2);
int result2 = sum(1, 2, 3);
int result3 = sum(1.0, 2.0);

通过方法的重载，我们可以使用相同的方法名来完成不同的功能，这样可以提高代码的重用性和可读性。

在谈到参数个数可以确定两个方法是否具有重载关系时，会想到定义不定长参数方法。不定长方法语法如下：

返回值方法名(参数数据类型…参数名称)

在上述实例中，在参数列表中使用“…”形式定义不定长参数，其实这个不定长参数a就是一个数组，编译器会将“int…a”这种形式看成“int[] a”，所以在add()方法体做累加操作时使用到了for循环语句，在循环中是根据数组a的长度作为循环条件的，最后将累加结果返回。

6.final关键字

final 是 Java 中的一个关键字，可以用来修饰类、方法和变量。使用 final 修饰的类不能被继承，使用 final 修饰的方法不能被子类重写，使用 final 修饰的变量不能被修改。

6.1 final变量

final关键字可以用于修饰变量，被final修饰的变量称为final变量。final变量是指在声明时必须被初始化，并且在程序执行过程中其值不可更改的变量。

final变量的值一旦被赋值就不能再改变，这使得程序具有更好的安全性和稳定性。在Java编程中，final变量通常用来表示常量或配置参数。

6.2 final方法

final关键字可以用于修饰类、方法和变量。当final用于修饰方法时，该方法就称为final方法。

final方法是指在类中声明的方法，在子类中不能被重写或覆盖。这意味着，当一个方法被声明为final时，它的实现在父类中是最终的，子类不能对其进行修改。

下面是一个示例代码，演示了如何在Java中使用final方法：

csharpCopy codepublic class Animal {
    public final void move() {
        System.out.println("Animal is moving...");
    }
}

public class Cat extends Animal {
    // 重写move方法会引发编译时错误
}

在这个例子中，Animal类定义了一个名为move的final方法。由于move方法被声明为final，它不能在子类中被重写或覆盖。因此，在Cat类中重写move方法会引发编译时错误。

final方法的优点是能够防止子类修改父类中的行为。如果一个方法被声明为final，那么它的实现在所有子类中都是不变的。这可以确保程序的稳定性和可靠性，同时也可以提高程序的执行效率。

6.3 final类

在Java中，final关键字可以用于修饰类，被final修饰的类称为final类。final类是指不能被继承的类，即其子类不能被创建。

当一个类被声明为final时，它的实现在程序执行过程中是最终的，不能被修改或扩展。这意味着，final类的行为在所有的子类中都是不变的，可以确保程序的稳定性和安全性。

下面是一个示例代码，演示了如何在Java中使用final类：

arduinoCopy codepublic final class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
    public static int multiply(int a, int b) {
        return a * b;
    }
}

在这个例子中，定义了一个名为MathUtils的final类。由于MathUtils类被声明为final，它不能被继承，即其子类不能被创建。MathUtils类中包含了两个静态方法add和multiply，这些方法可以被其他类直接调用，无需创建MathUtils类的实例。

final类的优点是可以确保程序的稳定性和安全性，同时也可以提高程序的执行效率。因为final类不能被继承，所以它的实现在所有的子类中都是不变的，这可以防止子类修改或扩展final类的行为。

7.多态

在Java中，多态是指同一种行为或操作作用于不同的对象时，可以产生不同的结果。具体来说，多态可以通过继承和接口实现。

继承多态：子类可以重写父类的方法，当父类的引用指向子类的对象时，调用该方法时会调用子类中的方法实现。这种行为称为动态绑定或运行时绑定。例如：

csharpCopy codepublic class Animal {
    public void move() {
        System.out.println("Animal is moving...");
    }
}

public class Cat extends Animal {
    public void move() {
        System.out.println("Cat is moving...");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.move(); // 输出：Cat is moving...
    }
}

在这个例子中，定义了一个名为Animal的父类和一个名为Cat的子类，Cat类重写了Animal类中的move方法。在主方法中，创建了一个Animal类的引用，指向Cat类的对象。当调用animal.move()方法时，输出的结果为"Cat is moving…"，这说明方法的实现是动态绑定的，即运行时决定调用哪个方法。

接口多态：当一个类实现了接口后，可以通过接口类型的引用指向该类的对象。这种行为称为接口多态。例如：

csharpCopy codepublic interface Shape {
    void draw();
}

public class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing a rectangle...");
    }
}

public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a circle...");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Rectangle();
        Shape shape2 = new Circle();
        shape1.draw(); // 输出：Drawing a rectangle...
        shape2.draw(); // 输出：Drawing a circle...
    }
}

在这个例子中，定义了一个名为Shape的接口和两个实现了Shape接口的类Rectangle和Circle。在主方法中，创建了两个Shape类型的引用，分别指向Rectangle类和Circle类的对象。当调用shape1.draw()方法和shape2.draw()方法时，分别输出"Drawing a rectangle…“和"Drawing a circle…”，这说明方法的实现也是动态绑定的。

8.抽象类

使用abstract关键字定义的类称为抽象类，而使用这个关键字定义的方法称为抽象方法。抽象方法没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承，实际上抽象类除了被继承没有任何意义。定义抽象类的语法如下：

public abstract class Parent{
abstract void testAbstrac();   //定义抽象方法

抽象类被继承后需要实现其中所有的抽象方法，也就是保证以相同的方法名称，参数列表和返回值类型创建出的非抽象方法，当然也可以是抽象方法。

抽象方法
修饰符 abstract 返回参数 方法名（传入参数）；

抽象类 有抽象方法的类一定是抽象类
修饰符 abstract class 类名{
}

9接口

接口是抽象类的延伸，可以将它看作为是纯粹的抽象类，接口中的所有方法都没有方法体。

接口通过关键字“interface”来定义，接口中的方法默认是public abstract类型的，常量是public static final类型的。接口可以被类实现（implements），表示类遵循了该接口的规范，同时必须实现该接口中定义的所有抽象方法。语法如下：

public interface Paintable{
    void draw();        //定义接口方法可省略public abstract关键字
}

一个类可以实现多个接口，但只能继承一个父类。这使得接口成为了Java中实现多继承的一种方式。通过实现多个接口，一个类可以拥有多种类型的行为特征。

接口也可以继承（extends）其他接口，这使得接口可以通过继承机制扩展接口的行为特征。当一个接口继承了另一个接口时，它将自动包含另一个接口中的所有常量和方法定义。

总之，接口提供了一种机制，用于定义类的一组操作行为，并将这些行为规范化，以便在实现类中实现具体的操作行为。

Shion_online

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第二篇Java基础知识的复习笔记

仅供学习参考
复制链接

扫一扫