文章目录

1. 变量：
- 变量的声明和初始化
- 变量的作用域
- 变量的命名规则
- 常量
2. 运算符：
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 其他运算符
3. 流程控制：
- 分支结构
- 循环结构
- 跳转控制
4. 类与对象：
- 类的概念
- 对象的概念
- 类的成员
- 构造方法和析构方法
- 封装、继承和多态
5. 继承与多态：
- 继承的基本概念
- 继承的特点
- 多态的基本概念
- 多态的实现方式
- 强制类型转换
- 抽象类与抽象方法
- 接口
- 总结
6. 接口：
- 接口的概念
- 接口的特点
- 接口的使用方法
- 接口的实现
- 接口的继承
- 接口的应用场景
7. 泛型：
- 泛型的概念
- 泛型的特点
- 泛型的使用方法
- 泛型类
- 泛型方法
- 通配符
- 泛型的应用场景
- - 泛型类
  - 泛型方法
  - 通配符
  - 泛型接口
  - 泛型枚举

1. 变量：

在Java中，变量需要先声明再使用，声明方式为"数据类型变量名"。Java有八种基本数据类型：byte、short、int、long、float、double、char、boolean。除了基本类型，Java还支持引用类型，如字符串和数组。
下面我将更详细地介绍Java中的变量。

变量的声明和初始化

在Java中，变量需要先声明再使用。变量的声明包括数据类型和变量名两部分，如下所示：

int age;
double salary;
String name;

这里的 int、double 和 String 分别是Java中的基本数据类型。除了基本类型，Java还支持引用类型，包括类类型、接口类型、数组类型等。

变量声明后可以进行初始化，即给变量赋一个初始值。变量的初始化方式有以下几种：

直接赋值：例如 int a = 10;。
通过表达式赋值：例如 int b = a + 5;。
通过方法返回值赋值：例如 String s = "Hello".toLowerCase();。

变量的作用域

Java中的变量有作用域的概念，即变量在程序中有效的范围。变量的作用域由它的声明位置决定，通常来说，在声明变量时就应该尽可能明确其作用域。

Java中有四个作用域：类级别、实例级别、局部块级别和形参级别。

类级别的变量（也称为类变量或静态变量）是在类中使用 static 关键字声明的变量，其作用域为整个类。在类被加载时就会被创建，且只有一个实例。例如：
```
public class MyClass {
    static int count = 0;
    // ...
}
```
实例级别的变量（也称为成员变量）是在类中声明的变量，其作用域为整个实例。每个对象都有一份独立的实例变量，可以通过对象访问。例如：
```
public class Person {
    String name;
    int age;
    // ...
}
```

局部块级别的变量是在代码块中声明的变量，其作用域为该代码块内部。例如：

public void myMethod() {
    int x = 10;
    if (x > 5) {
        int y = 20;
        // ...
    }
    // ...
}

形参级别的变量是在方法参数中声明的变量，其作用域为方法内部。例如：
```
public void myMethod(int a, String b) {
    // ...
}
```

变量的命名规则

Java中的变量名要求必须遵循以下规则：

变量名必须以字母、下划线或美元符号开头。
变量名不能使用Java保留关键字。
变量名区分大小写。
变量名应该具有描述性，以便于阅读和理解。
变量名不应该使用缩写。

常量

常量是指在程序运行期间值不能被改变的量。在Java中，可以使用 final 关键字来声明常量。例如：

final double PI = 3.1415926;
final String NAME = "John";

在声明常量时，必须同时进行赋值操作，并且一旦赋值后就不能再次修改。

总之，Java中的变量是一个非常基础和重要的概念，在编程过程中需要反复使用。因此，理解并熟练掌握Java中的变量是非常必要的。

2. 运算符：

Java支持多种运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符等。其中算术运算符包括"+、-、*、/、%、++、–“；关系运算符包括”==、!=、>、<、>=、<=“；逻辑运算符包括”&&、||、!“；位运算符包括”&、|、^、~、<<、>>、>>>等。

好的，下面我将详细介绍Java中的运算符。

算术运算符

Java中的算术运算符包括加、减、乘、除、模和自增自减运算符。

运算符	描述
+	加
-	减
*	乘
/	除
%	取模（取余）
++	自增
–	自减

其中，自增自减运算符只能用于操作变量。例如：

int a = 10, b = 5;
int c = a + b;      // c = 15
int d = a - b;      // d = 5
int e = a * b;      // e = 50
int f = a / b;      // f = 2
int g = a % b;      // g = 0
a++;                // a = 11
b--;                // b = 4

关系运算符

Java中的关系运算符用于比较两个值的大小或相等关系，其结果为布尔类型（true/false）。

运算符	描述
==	相等
!=	不相等
>	大于
<	小于
>=	大于等于
<=	小于等于

例如：

int a = 10, b = 5;
boolean c = (a == b);   // c = false
boolean d = (a != b);   // d = true
boolean e = (a > b);    // e = true
boolean f = (a < b);    // f = false
boolean g = (a >= b);   // g = true
boolean h = (a <= b);   // h = false

逻辑运算符

Java中的逻辑运算符用于将多个条件联合起来进行判断，其结果为布尔类型。

运算符	描述
&&	与
\|\|	或
!	非（取反）

例如：

int a = 10, b = 5;
boolean c = (a > 5) && (b < 10);  // c = true
boolean d = (a < 5) || (b > 10);  // d = false
boolean e = !(a == 10);           // e = false

位运算符

Java中的位运算符是对二进制数按位进行运算。它们操作数的每一位都会参与运算，并按照位进行相应的运算。Java中的位运算符包括按位与、按位或、按位异或、按位取反、左移和右移。

运算符	描述
&	按位与
\|	按位或
^	按位异或
~	按位取反
<<	左移
>>	算术右移
>>>	逻辑右移（无符号右移）

例如：

int a = 0b10101010;
int b = 0b11001100;
int c = a & b;     // c = 0b10001000
int d = a \| b;     // d = 0b11101110
int e = a ^ b;     // e = 0b01100110
int f = ~a;        // f = 0b01010101
int g = a << 2;    // g = 0b1010101000
int h = a >> 2;    // h = 0b00101010
int i = a >>> 2;   // i = 0b00001010

其他运算符

包括条件运算符、赋值运算符、位移赋值运算符和三目运算符。

条件运算符（三元运算符）：Java中的条件运算符也称为三元运算符，它用于根据布尔表达式的结果来选择两个值中的一个。语法格式为 boolean ? value1 : value2。例如：
```
int a = 10, b = 5;
int max = (a > b) ? a : b;   // max = 10
```
赋值运算符：Java中的赋值运算符用于给变量赋值。常见的赋值运算符包括 =、+=、-=、*=、/=、%= 等。例如：
```
int a = 10, b = 5;
a += b;     // 相当于 a = a + b，a = 15
b *= 2;     // 相当于 b = b * 2，b = 10
```
位移赋值运算符：Java中的位移赋值运算符是对变量进行位移后再赋值。常见的位移赋值运算符包括 <<=、>>=、>>>= 等。例如：
```
int a = 0b10101010;
a <<= 2;    // 相当于 a = a << 2，a = 0b1010101000
a >>>= 2;   // 相当于 a = a >>> 2，a = 0b10101010
```
三目运算符：Java中的三目运算符也称条件运算符，语法格式为 condition ? expr1 : expr2。其中，condition 是一个布尔表达式，expr1 和 expr2 是两个可能返回不同类型值的表达式。例如：
```
int a = 10, b = 5;
String result = (a > b) ? "a > b" : "a <= b";    // result = "a > b"
```

总之，Java中有多种运算符可供使用，每种运算符都有其独特的用途和语法规则。在编程过程中，我们需要根据实际情况选择合适的运算符来完成相应的操作。

3. 流程控制：

Java提供了多种流程控制语句，包括if语句、switch语句、while循环、do…while循环、for循环等。if语句用于条件判断，switch语句用于多重分支，while循环和do…while循环用于循环操作，for循环则可以更加灵活地控制循环次数。

下面我将详细介绍Java中的流程控制。

分支结构

在Java中，分支结构有两种方式：if-else语句和switch语句。

if-else语句：if-else语句用于根据条件来执行不同的代码块。语法格式如下：

if (condition) {
    // 如果condition为真，则执行此处代码块
} else {
    // 如果condition为假，则执行此处代码块
}

示例代码：

int score = 80;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else {
    System.out.println("一般");
}

switch语句：switch语句也用于根据不同条件执行不同的代码块。与if-else语句不同的是，switch语句基于一个表达式的值来选择要执行的代码块。语法格式如下：

switch (expression) {
    case value1:
        // 如果expression的值等于value1，则执行此处代码块
        break;
    case value2:
        // 如果expression的值等于value2，则执行此处代码块
        break;
    default:
        // 如果expression的值都不满足，则执行此处代码块
}

示例代码：

int day = 3;
switch (day) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    default:
        System.out.println("未知");
}

循环结构

在Java中，循环结构有三种方式：for循环、while循环和do-while循环。

for循环：for循环用于重复执行一段代码块，通常是在已知循环次数的情况下使用。语法格式如下：

for (initialization; condition; update) {
    // 在条件满足的情况下，重复执行此处代码块
}

示例代码：

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

while循环：while循环用于重复执行一段代码块，直到指定的条件不再满足为止。语法格式如下：

while (condition) {
    // 在条件满足的情况下，重复执行此处代码块
}

示例代码：

int i = 1;
while (i <= 10) {
    System.out.println(i++);
}

do-while循环：do-while循环与while循环类似，只不过它先执行一次循环体，然后再判断条件是否满足。语法格式如下：

do {
    // 先执行一次此处代码块，然后在条件满足的情况下重复执行
} while (condition);

示例代码：

int i = 1;
do {
    System.out.println(i++);
} while (i <= 10);

跳转控制

在Java中，跳转控制有三种方式：break语句、continue语句和return语句。

break语句：break语句用于退出循环体或switch语句。当break语句被执行时，程序会跳出当前循环体或switch语句。示例代码：
```
for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}
```
continue语句：continue语句用于跳过本次循环剩余部分，进入下一次循环。当continue语句被执行时，程序会跳过本次循环的剩余代码，直接进入下一次循环。示例代码：
```
for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        continue;
    }
    System.out.println(i);
}
```
return语句：return语句用于从方法中返回一个值，或者终止方法的执行。当return语句被执行时，程序会立即退出当前方法。如果在方法中返回一个值，则需要在return语句后面加上返回值。示例代码：
```
public int add(int a, int b) {
    return a + b;
}
```

总之，Java中的流程控制包括分支结构、循环结构和跳转控制。不同的控制结构有着不同的特点和使用场景，开发者可以根据具体需求来选择合适的控制结构。

4. 类与对象：

Java是面向对象的编程语言，类是面向对象程序设计的基础。类定义了对象所包含的属性和方法，对象则是类的具体实例。Java中可以使用new关键字来创建对象，并且可以通过"."操作符来访问对象的属性和方法。

下面我将详细介绍Java中的类与对象。

类的概念

在Java中，类是用来描述一种具有相同属性和行为的对象集合的模板或蓝图。类可以包含数据成员（属性）和成员方法（行为），用于描述对象的状态和行为。Java中的类使用关键字class进行定义，语法格式如下：

修饰符 class 类名 {
    // 数据成员（属性）
    // 成员方法（行为）
}

其中，修饰符可以省略，类名是标识符，数据成员和成员方法可以有多个。

示例代码：

public class Person {
    // 数据成员
    private String name;
    private 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 + ", I'm " + age + " years old.");
    }
}

对象的概念

在Java中，对象是类的实例化结果，即某个类的具体实体。对象具有该类所定义的属性和行为，并且可以独立于其他对象存在。Java中的对象是通过new关键字创建的，语法格式如下：

类名 对象名 = new 类名();

其中，类名是要实例化的类的名称，对象名是新创建对象的引用变量。示例代码：

Person p = new Person("Tom", 20);
p.sayHello();   // 输出：Hello, my name is Tom, I'm 20 years old.

类的成员

Java中的类成员包括数据成员和成员方法。

数据成员（属性）：数据成员用于描述对象的状态，它们是类的实例变量，可以是基本数据类型或引用类型。Java中的数据成员可以使用访问修饰符来限定访问级别，包括public、protected、private和默认访问级别。
成员方法（行为）：成员方法用于描述对象的行为，它们是类的实例方法，可以访问和修改数据成员。成员方法也可以使用访问修饰符来限定访问级别。Java中的成员方法可以分为静态方法和非静态方法（实例方法）。

构造方法和析构方法

构造方法：构造方法用于创建对象时初始化对象的状态，它与类名相同，并且没有返回值类型。在Java中，每个类都有一个默认的无参构造方法，如果自定义了构造方法，则必须显式地定义该方法。示例代码：

public class Person {
    private String name;
    private int age;

    // 带参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 默认的无参构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 成员方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
    }
}

析构方法：Java中没有析构方法，当一个对象不再被引用时，垃圾回收机制会自动回收该对象的内存空间。

封装、继承和多态

封装：封装是面向对象编程中的一种重要原则，它通过控制类成员的访问级别来保护数据安全性，使代码更加健壮、易于维护和拓展。在Java中，可以使用访问修饰符来限定数据成员和成员方法的访问级别，包括public、protected、private和默认访问级别。
继承：继承是一种面向对象编程中的机制，它允许一个类从另一个类继承属性和行为。被继承的类称为父类或基类，继承的类称为子类或派生类。在Java中，使用extends关键字来实现继承关系。子类可以继承父类的公有数据成员和成员方法，并且可以重写父类的方法以实现特定需求。
多态：多态是面向对象编程中的一种特性，它允许不同的对象对同一消息做出不同的响应。在Java中，多态可以通过方法重载和方法重写来实现。方法重载是指在一个类中定义多个具有相同方法名但参数列表不同的方法；方法重写是指在子类中对父类的某个方法进行重新定义。在运行时，Java虚拟机会根据实际调用的对象类型来确定调用哪个方法。

总之，类与对象是面向对象编程的核心概念，它们可以帮助开发者更好地组织代码、封装数据和实现复杂功能。除此之外，封装、继承和多态也是面向对象编程的重要特性，它们促进了代码的重用和扩展，提高了代码的可读性、可维护性和可靠性。

5. 继承与多态：

Java支持继承和多态。继承是一种面向对象编程的重要技术，它可以使一个新的类获取已有类的属性和方法。多态指的是同一个方法在不同情况下表现出不同的行为。

下面我将详细介绍Java中的继承与多态。

继承的基本概念

在Java中，继承是一种面向对象编程的机制，它允许一个类从另一个类继承属性和行为。被继承的类称为父类或基类，继承的类称为子类或派生类。继承使得代码重用更加容易，同时也提高了代码的可读性和可维护性。

Java中使用关键字extends来实现继承关系，示例代码如下：

public class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking.");
    }
}

在上面的代码中，Dog类继承自Animal类，因此Dog类具有父类Animal中的成员方法eat()。

继承的特点

子类可以继承父类的成员变量和成员方法，包括公有、受保护和默认访问级别的成员。
子类可以重写父类的成员方法以实现特定需求。
子类可以添加新的成员变量和成员方法，以满足特定需求。
子类不能直接访问父类的私有成员变量和私有成员方法，但可以通过父类的公有或受保护成员方法来访问。

多态的基本概念

多态是面向对象编程中的一种特性，它允许不同的对象对同一消息做出不同的响应。在Java中，多态可以通过方法重载和方法重写来实现。

方法重载：方法重载是指在一个类中定义多个具有相同方法名但参数列表不同的方法。Java会根据方法的参数列表来决定调用哪个方法。
方法重写：方法重写是指在子类中对父类的某个方法进行重新定义。子类重写的方法必须与父类的方法具有相同的名称、参数列表和返回类型，并且访问修饰符不能更严格。

示例代码：

public class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating bones.");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating fish.");
    }
}

上述代码中，Dog类和Cat类都重写了父类Animal中的eat()方法。当调用eat()方法时，Java虚拟机会根据具体调用的对象类型来决定调用哪个方法。

多态的实现方式

在Java中，多态有两种实现方式：通过继承和接口来实现多态。

通过继承实现多态：

在继承体系中，父类指针可以指向子类对象。使用父类的引用变量来调用重写的方法时，Java虚拟机会根据具体调用的对象类型来决定调用哪个方法。

示例代码：
```
Animal ani1 = new Dog();
Animal ani2 = new Cat();
ani1.eat();   // 输出：Dog is eating bones.
ani2.eat();   // 输出：Cat is eating fish.
```
通过接口实现多态：

接口是一种特殊的抽象类，它只定义了方法的声明而没有提供方法的实现。一个类可以实现多个接口，从而具有不同的行为特征。Java中通过将对象引用转换为接口类型来实现多态。使用接口的引用变量来调用实现类中的方法时，Java虚拟机会根据具体调用的对象类型来决定调用哪个方法。

示例代码：

interface Shape {
    void draw();
}

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

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

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

在上述代码中，Circle和Rectangle类都实现了Shape接口，并重写了接口中的draw()方法。当使用接口的引用变量来调用实现类中的方法时，Java虚拟机会根据具体调用的对象类型来决定调用哪个方法。

强制类型转换

在Java中，可以使用强制类型转换将父类引用变量转换为子类引用变量，以方便访问子类特有的成员。

示例代码：

Animal ani = new Dog();
if (ani instanceof Dog) {
    Dog d = (Dog)ani;
    d.bark();
}

在上述代码中，ani是一个Animal类的引用变量，但它指向的是一个Dog类的实例。通过使用instanceof运算符可以判断ani是否指向了一个Dog类的实例。如果是，则可以使用强制类型转换将ani转换为Dog类型，以便访问Dog类特有的方法bark()。

需要注意的是，如果进行强制类型转换时，实际对象不是所需类型的子类，会抛出ClassCastException异常。因此，在进行强制类型转换之前，最好先使用instanceof运算符进行类型检查。
6. 调用父类的构造方法

在Java中，子类继承了父类的所有属性和方法，但并没有继承父类的构造方法。因此，在子类的构造方法中调用父类的构造方法是非常必要的，以确保父类的成员变量得到正确的初始化。

在子类的构造方法中使用super关键字来调用父类的构造方法。如果父类有多个构造方法，则可以通过super关键字指定需要调用的构造方法。

示例代码：

public class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
}

public class Dog extends Animal {
    private int age;
    public Dog(String name, int age) {
        super(name);  // 调用父类的构造方法
        this.age = age;
    }
}

在上述代码中，Dog类继承自Animal类，并在其构造方法中调用了Animal类的构造方法。

抽象类与抽象方法

抽象类是一种特殊的类，它不能被实例化，只能作为其他类的父类使用。抽象类中可以包含抽象方法，抽象方法没有具体的实现，只有方法的声明。

在Java中，使用abstract关键字来定义一个抽象类或抽象方法。如果一个类包含抽象方法，则这个类必须是抽象类。

示例代码：

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Draw a circle.");
    }
}

class Rectangle extends Shape {
    @Override
    void draw() {
        System.out.println("Draw a rectangle.");
    }
}

在上述代码中，Shape类是一个抽象类，其中包含了一个抽象方法draw()。Circle类和Rectangle类都继承自Shape类，并实现了draw()方法。

需要注意的是，如果一个类继承了一个抽象类，则必须实现抽象类中的所有抽象方法，否则该类也必须声明为抽象类。

接口

接口是一种特殊的抽象类，它只定义了方法的声明而没有提供方法的实现。一个类可以实现多个接口，从而具有不同的行为特征。

在Java中，使用interface关键字来定义一个接口。接口中的方法默认都是公有的抽象方法，也可以定义常量和默认方法、静态方法。

示例代码：

interface Shape {
    double PI = 3.14;  // 定义常量
    void draw();       // 定义抽象方法
    default void show() {   // 定义默认方法
        System.out.println("This is a shape.");
    }
    static void info() {    // 定义静态方法
        System.out.println("This is a shape interface.");
    }
}

class Circle implements Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public void draw() {
        System.out.println("Draw a circle with radius " + radius);
    }
}

在上述代码中，Shape接口定义了一个常量PI，以及一个抽象方法draw()、一个默认方法show()、一个静态方法info()。Circle类实现了Shape接口，并重写了其中的draw()方法。

需要注意的是，如果一个类实现了一个接口，则必须实现接口中的所有方法，否则该类必须声明为抽象类。

总结

继承和多态是面向对象编程中非常重要的概念。继承使得代码重用更加容易，同时也提高了代码的可读性和可维护性。多态是面向对象编程中一个非常强大的特性，它可以让不同的对象对同一消息做出不同的响应。

在Java中，使用extends关键字来实现继承关系，使用super关键字来调用父类的构造方法。多态可以通过方法重载和方法重写来实现，以及通过接口来实现。在进行强制类型转换时，需要注意进行类型检查，避免发生ClassCastException异常。此外，抽象类和接口也是面向对象编程中非常重要的概念，它们可以帮助我们更好地组织代码、封装数据和实现复杂功能。

6. 接口：

Java中的接口是一组抽象方法的集合。接口可以被类实现，而一个类也可以实现多个接口。接口使用interface关键字进行定义。
下面我将详细介绍Java中接口的概念、特点、使用方法及应用场景。

接口的概念

在Java中，接口是一种特殊的抽象类，它只包含方法定义和常量声明，而没有具体的方法实现。接口可以让多个不同的类实现相同的方法，从而达到代码重用的目的。同时，接口也可以用于实现回调机制（callback），即某个对象在特定情况下调用另一个对象的方法。

接口的特点

接口中的所有方法都是公有的抽象方法，不包含具体的方法实现。
接口中可以定义常量，但不能定义变量。
接口不能被实例化，只能被实现。
一个类可以实现多个接口。
一个接口可以继承多个接口。

接口的使用方法

在Java中，使用关键字interface来定义一个接口。接口中的方法默认都是公有的抽象方法，可以在方法名前添加abstract关键字，但不是必须的。

示例代码：

public interface Shape {
    double getArea();
    double getPerimeter();
}

在上述代码中，定义了一个Shape接口，其中包含了两个方法getArea()和getPerimeter()，这两个方法都是公有的抽象方法。该接口可以被其他类实现，以提供不同的形状计算面积和周长的功能。

接口的实现

在Java中，使用关键字implements来实现一个接口。一个类可以实现多个接口，实现接口的类必须实现接口中声明的所有方法。

示例代码：

public class Circle implements Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

在上述代码中，Circle类实现了Shape接口，并重写了其中的getArea()和getPerimeter()方法。

接口的继承

在Java中，接口也可以继承另一个接口，从而允许子接口继承父接口的方法定义。

示例代码：

public interface Drawable {
    void draw();
}

public interface Shape extends Drawable {
    double getArea();
    double getPerimeter();
}

在上述代码中，Shape接口继承了Drawable接口，并扩展了两个新的方法getArea()和getPerimeter()。

接口的应用场景

实现多态：接口可以让多个不同的类实现相同的方法，从而达到代码重用的目的。
实现回调机制：接口可以用于实现回调机制，即某个对象在特定情况下调用另一个对象的方法。
限制类的继承：接口可以作为一种约束，限制某个类的继承关系。如果某个类实现了某个接口，就必须实现该接口中声明的所有方法。
定义常量：接口可以定义常量，供其他类使用。

总之，接口是Java中非常重要的概念之一，它可以让我们更好地组织代码、封装数据和实现复杂功能。在设计API时，接口也是非常常见的一种设计模式，它可以提高 API 的可扩展性和可维护性。

7. 泛型：

泛型是Java语言中的一个强大特性，它可以使代码更加灵活和安全。使用泛型可以将类型参数化，从而使代码更好地适应不同的数据类型。

好的，下面我将详细介绍Java中泛型的概念、特点、使用方法及应用场景。

泛型的概念

在Java中，泛型（Generic）是一种参数化类型的机制，它可以让我们定义一个类或方法，使其可以支持多种不同的数据类型。通俗地说，泛型就是把数据类型作为参数传递给类或方法，从而实现代码的重用和扩展。

泛型的特点

泛型支持可编译时类型检查，能够在编译时发现类型错误。
泛型可以减少代码重复，提高代码的可读性和可维护性。
泛型可以增加程序的灵活性和扩展性。

泛型的使用方法

在Java中，使用尖括号<>来指定泛型类型，例如：

List<String> list = new ArrayList<>();

在上述代码中，List是一个泛型接口，其中包含了多个操作列表的方法，String表示元素的类型，ArrayList是一个基于数组实现的 List 接口的可变长度的数组序列。

泛型类

在Java中，我们可以定义一个泛型类，使其可以支持多种不同类型的对象。泛型类在定义时要在类名后面添加类型参数，如下所示：

public class Box<T> {
    private T data;
    public Box(T data) {
        this.data = data;
    }
    public T getData() {
        return data;
    }
}

在上述代码中，Box类是一个泛型类，其中定义了一个类型参数T，表示Box可以存储任意类型的数据。在创建Box对象时，需要指定T的具体类型。

泛型方法

在Java中，我们也可以定义一个泛型方法，使其可以支持多种不同类型的参数。泛型方法在定义时要在方法名前面添加类型参数，如下所示：

public class ArrayUtil {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }
}

在上述代码中，printArray()是一个泛型方法，其中定义了一个类型参数T，表示该方法可以处理任意类型的数组。在调用printArray()方法时，需要指定T的具体类型。

通配符

在Java中，我们可以使用通配符（wildcard）来表示某种类型的子类或父类。

? extends T 表示某种类型的子类。
? super T 表示某种类型的父类。

示例代码：

public class Animal {}
public class Dog extends Animal {}

List<? extends Animal> list1 = new ArrayList<Dog>(); // 子类向父类转换
List<? super Dog> list2 = new ArrayList<Animal>(); // 父类向子类转换

在上述代码中，list1表示包含所有Animal的子类的List，可以接收Dog类型的List；list2表示包含所有Dog的父类的List，可以接收Animal类型的List。这样就可以实现子类向父类转换和父类向子类转换。

泛型的应用场景

集合类：Java中的集合类（如List、Set、Map等）都是使用泛型来实现的。
接口与抽象类：泛型可以被用于接口和抽象类中，使其支持多种不同类型的对象。
类型安全：泛型可以保证编写类型安全的代码，避免了强制类型转换时的运行时错误。
反射机制：泛型可以与反射机制相结合，使得我们可以在运行时获取到泛型信息。

总之，泛型是Java中非常重要的概念之一，泛型可以使我们在编译时发现类型错误，从而提高代码的健壮性和可读性。它还可以减少代码重复，提高代码的可维护性和可扩展性。

二，泛型不仅适用于类，还适用于方法。在定义泛型方法时，需要在方法名前面添加类型参数。

三，通配符是泛型中一个非常重要的概念，它可以用来表示某种类型的子类或父类。比如List<? extends Number>表示包含所有Number的子类的List，而List<? super Integer>表示包含所有Integer的父类的List。

四，泛型的应用场景非常广泛，常见的有集合类、接口和抽象类、类型安全和反射机制等等。

下面是一些使用泛型的示例代码：

泛型类

public class Box<T> {
    private T data;
    public Box(T data) {
        this.data = data;
    }
    public T getData() {
        return data;
    }
}

在上述代码中，Box是一个泛型类，其中定义了一个类型参数T，表示Box可以存储任意类型的数据。

泛型方法

public class ArrayUtil {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }
}

在上述代码中，printArray()是一个泛型方法，其中定义了一个类型参数T，表示该方法可以处理任意类型的数组。

通配符

public class Animal {}
public class Dog extends Animal {}

List<? extends Animal> list1 = new ArrayList<Dog>(); // 子类向父类转换
List<? super Dog> list2 = new ArrayList<Animal>(); // 父类向子类转换

泛型接口

public interface Comparable<T> {
    int compareTo(T o);
}

在上述代码中，Comparable是一个泛型接口，其中定义了一个类型参数T，表示Comparable可以比较任意类型的对象。

泛型枚举

public enum Color {RED, GREEN, BLUE}
public enum Size {SMALL, MEDIUM, LARGE}

public class Shirt<T extends Enum<T>> {
    private T color;
    private T size;
    public Shirt(T color, T size) {
        this.color = color;
        this.size = size;
    }
    public T getColor() {
        return color;
    }
    public T getSize() {
        return size;
    }
}