Java 入门探索者15（接口，抽象类，实现类，集合，多态）

Java中的接口（Interface）是一种引用类型，它是方法声明的集合，用于指定一组方法规范，但不提供这些方法的具体实现。接口是一种强大的机制，用于实现多重继承，即一个类可以实现多个接口，从而继承多个接口中的方法。接口主要用于定义对象的行为规范，确保不同的类具有统一的方法签名，使得它们可以在不同的上下文中被互换使用，这是面向对象编程中多态性的一个重要体现。

接口的定义

接口使用interface关键字来定义，接口中的方法默认是public abstract的，即公开的且抽象的，因此接口中的方法不需要（也不能）有方法体。接口中还可以包含常量，这些常量默认是public static final的。

java复制代码

	public interface MyInterface {
	// 常量定义
	int MAX_VALUE = 100;
	// 方法声明，默认是public abstract
	void doSomething();
	// 另一个方法声明
	int calculate(int a, int b);
	}

接口的实现

类通过implements关键字来实现接口，实现接口的类必须提供接口中所有方法的具体实现（除非该类是抽象类）。

java复制代码

	public class MyClass implements MyInterface {
	// 实现接口中的方法
	@Override
	public void doSomething() {
	System.out.println("Doing something...");
	}
	@Override
	public int calculate(int a, int b) {
	return a + b;
	}
	}

接口的特性

1. 多重继承：一个类可以实现多个接口，从而继承多个接口中的方法。
2. 默认方法和静态方法（Java 8及以后）：接口中可以包含带有实现体的默认方法和静态方法，这允许在不破坏向后兼容性的情况下向接口中添加新方法。
3. 私有方法（Java 9及以后）：接口中可以包含私有方法，包括私有实例方法和私有静态方法，这些私有方法主要用于辅助接口中其他方法的实现。
4. 函数式接口（Java 8及以后）：如果一个接口只包含一个抽象方法（默认方法和静态方法不影响函数式接口的判定），那么这个接口就被称为函数式接口。函数式接口可以被隐式地转换为Lambda表达式或方法引用。

接口的用途

• 定义规范：接口定义了对象的行为规范，确保不同的类具有统一的方法签名。
• 解耦：通过接口，可以实现类与类之间的解耦，提高系统的灵活性和可扩展性。
• 实现多态：接口是实现多态性的重要手段，通过接口引用可以指向实现了该接口的任何对象。

总之，Java中的接口是一种强大的特性，它使得Java的面向对象编程更加灵活和强大。

package lesson16;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest {
    public static void main(String[] args) {
        //Collection是接口，需要用实现类创建对象
        Collection c =new ArrayList();
        //集合中保存了多少数据
        System.out.println("获取集合的长度"+c.size());
        //如果没有数据返回true，有数据返回false
        System.out.println("判断集合是否为空"+c.isEmpty());
        //往集合中添加数据用add方法
        c.add("张三");
        //集合中是不能保存基本数据类型的，只能保存对象类型
        //而基本数据类型可以保存的原因是1.5后基本数据类型会跟包装类类型进行默认转换
        c.add(123);
        c.add(true);
        c.add('a');
        c.add(95.5);
        //集合重写了Objectd的toString方法，所以打印显示的是内容不是地址
        System.out.println(c);
        System.out.println(c.size());
    }
}

抽象类和接口在Java等面向对象编程语言中扮演着不同的角色，它们之间存在多个显著的区别。以下是从定义、特性、使用场景等方面对抽象类和接口进行的详细比较：

定义与特性

	抽象类	接口
定义	抽象类是一个特殊的类，不能被实例化，但可以被其他类继承。它主要用于定义一组通用的属性和方法，其中可以包含抽象方法（无具体实现的方法）和具体方法（有具体实现的方法）。	接口是一种引用类型，是方法声明的集合，不能被实例化，只能被实现。它定义了对象的行为规范，即一组方法签名，不包含方法的具体实现。
关键字	使用abstract关键字定义。	使用interface关键字定义。
成员变量	可以包含实例变量和静态变量。	只能包含常量（默认public static final）。
方法	可以包含抽象方法和具体方法。抽象方法没有实现体，以分号结束；具体方法则包含实现体。	只能包含抽象方法（在Java 8及以后，可以包含默认方法和静态方法，但它们也有实现体，但不影响接口主要作为方法声明的集合的特性）。所有方法默认是public abstract的。
构造器	可以有构造器，但主要用于子类调用，不能用于实例化对象。	不能有构造器，因为它是完全抽象的。
继承与实现	一个类只能继承一个抽象类（Java不支持多继承），但可以实现多个接口。	一个类可以实现多个接口，但接口之间可以有继承关系（即一个接口可以继承另一个接口）。
访问权限	访问权限可以是public、protected和包级私有（默认，无修饰符）。	只能是public，因为接口是定义公共的API。

使用场景与目的

• 抽象类：主要用于代码复用，当多个类之间存在共同属性和方法时，可以将这些共同特征抽象成一个抽象类，让其他类继承这个抽象类。同时，抽象类也支持多态性，可以通过抽象类引用指向其子类对象。
• 接口：主要用于定义行为规范，即一组方法签名。接口强制要求实现它的类必须实现接口中的所有方法（除非这些方法是默认方法或静态方法）。接口支持多重继承，使得一个类可以同时实现多个接口，从而具有多个接口定义的行为规范。

总结

抽象类和接口都是面向对象编程中的重要概念，它们各自具有独特的特性和使用场景。抽象类主要用于代码复用和多态性，而接口则主要用于定义行为规范和支持多重继承。在实际开发中，应根据具体需求选择合适的抽象类或接口来构建系统架构。

当然，我会通过具体的例子来详细描述抽象类和接口的使用。

抽象类实例

假设我们有一个场景，其中有多种交通工具，如汽车、火车和飞机。这些交通工具都有一些共通的属性（如名称、制造商）和共通的行为（如移动），但每种交通工具的移动方式都是不同的。此外，我们还想定义一个通用的交通工具类，它包含一些共通的方法实现，但也有一些方法是抽象的，需要子类去实现。

java复制代码

	// 抽象类：交通工具
	abstract class Transportation {
	String name;
	String manufacturer;
	// 构造器
	public Transportation(String name, String manufacturer) {
	this.name = name;
	this.manufacturer = manufacturer;
	}
	// 通用的方法实现
	public void displayInfo() {
	System.out.println("Name: " + name + ", Manufacturer: " + manufacturer);
	}
	// 抽象方法：移动
	public abstract void move();
	}
	// 继承抽象类的子类：汽车
	class Car extends Transportation {
	public Car(String name, String manufacturer) {
	super(name, manufacturer);
	}
	// 实现抽象方法
	@Override
	public void move() {
	System.out.println(name + " is moving on the road.");
	}
	}
	// 另一个继承抽象类的子类：飞机
	class Airplane extends Transportation {
	public Airplane(String name, String manufacturer) {
	super(name, manufacturer);
	}
	// 实现抽象方法
	@Override
	public void move() {
	System.out.println(name + " is flying in the air.");
	}
	}
	// 使用
	public class Main {
	public static void main(String[] args) {
	Car car = new Car("Tesla Model S", "Tesla");
	Airplane airplane = new Airplane("Boeing 747", "Boeing");
	car.displayInfo();
	car.move();
	airplane.displayInfo();
	airplane.move();
	}
	}

接口实例

再来看一个接口的实例。假设我们有一个场景，其中有多种类型的生物，它们都可以发出声音，但我们不知道每种生物具体会发出什么样的声音。我们可以定义一个SoundMaker接口，让不同的生物类去实现它。

java复制代码

	// 接口：声音制造者
	interface SoundMaker {
	void makeSound();
	}
	// 实现接口的类：狗
	class Dog implements SoundMaker {
	@Override
	public void makeSound() {
	System.out.println("Woof!");
	}
	}
	// 实现接口的类：猫
	class Cat implements SoundMaker {
	@Override
	public void makeSound() {
	System.out.println("Meow!");
	}
	}
	// 使用
	public class Main {
	public static void main(String[] args) {
	SoundMaker dog = new Dog();
	SoundMaker cat = new Cat();
	dog.makeSound();
	cat.makeSound();
	}
	}

在这个例子中，SoundMaker接口定义了一个方法makeSound，但没有提供实现。Dog和Cat类分别实现了这个方法，给出了不同的实现细节。这样，我们就能够通过接口引用（如SoundMaker类型的变量）来调用不同生物发出声音的方法，而不需要知道具体是哪种生物，这体现了多态性。

在Java中，实现类（Implementation Class）是一个非常重要的概念，它指的是实现了接口（Interface）或继承了抽象类（Abstract Class）的具体类。这些实现类提供了接口中所有方法的具体实现，或者为抽象类中的抽象方法提供了具体的实现。通过这种方式，Java支持了多态性和代码的复用。

实现接口

当一个类实现了接口时，它必须实现接口中声明的所有方法（从Java 8开始，接口中可以包含默认方法和静态方法，这些方法可以有实现体，但非默认方法仍然需要被实现）。这是因为接口是一种契约，规定了实现该接口的类必须遵守的行为规范。

java复制代码

	interface Animal {
	void eat();
	void sleep();
	}
	// Dog类实现了Animal接口
	class Dog implements Animal {
	@Override
	public void eat() {
	System.out.println("Dog is eating.");
	}
	@Override
	public void sleep() {
	System.out.println("Dog is sleeping.");
	}
	}
	// 使用
	public class Main {
	public static void main(String[] args) {
	Animal myDog = new Dog();
	myDog.eat();
	myDog.sleep();
	}
	}

在上面的例子中，Dog类通过implements关键字实现了Animal接口，并提供了eat和sleep方法的具体实现。

继承抽象类

当一个类继承了一个抽象类时，它必须为抽象类中的所有抽象方法提供具体实现，除非它自己也是一个抽象类。抽象类可以包含抽象方法和具体方法，以及字段和构造器（但构造器不能是抽象的）。

java复制代码

	abstract class Vehicle {
	abstract void move();
	void displayInfo() {
	System.out.println("This is a vehicle.");
	}
	}
	// Car类继承了Vehicle抽象类，并实现了move方法
	class Car extends Vehicle {
	@Override
	public void move() {
	System.out.println("Car is moving on the road.");
	}
	}
	// 使用
	public class Main {
	public static void main(String[] args) {
	Car myCar = new Car();
	myCar.move();
	myCar.displayInfo(); // 继承自Vehicle的方法
	}
	}

在这个例子中，Car类通过extends关键字继承了Vehicle抽象类，并为move方法提供了具体实现。同时，它也继承了Vehicle中的displayInfo方法，该方法在Vehicle类中已经有了实现。

总结

实现类在Java中扮演着将接口或抽象类的定义具体化的角色。它们通过提供接口方法的具体实现或继承并扩展抽象类来创建功能完善的类。这种方式促进了代码的复用、扩展和维护，也是面向对象编程中多态性的基础。

多态性（Polymorphism）是面向对象编程中的一个核心概念，它允许我们以统一的方式处理不同类型的对象。多态性在编程中主要体现为相同的操作或函数、方法对于不同的数据类型（对象）可以有不同的行为实现。以下是对多态性的详细解释：

定义

多态性，从字面意思上可以理解为“多种形态”或“多种表现形式”。在编程中，它指的是允许将父类类型的引用指向子类对象，并调用被子类重写的方法，而无需知道该对象的确切类型。

实现方式

多态性通常通过以下几种方式实现：

1. 方法的重写（Overriding）：子类提供一个与父类方法签名相同但实现不同的方法。当通过父类引用调用被子类重写的方法时，Java（或其他支持多态性的语言）会在运行时确定该引用实际指向的对象类型，并调用该对象类型中的方法。

2. 方法的重载（Overloading）：虽然重载不是多态性的主要实现方式（因为它与类型无关，而是与参数列表相关），但在一些上下文中，重载也可以看作是多态性的一种表现，因为它允许同一方法名具有不同的参数类型或数量。

3. 接口实现：在Java等语言中，接口定义了一组规范，任何实现该接口的类都必须实现接口中声明的方法。通过接口，不同的类可以实现相同的方法，但具有不同的行为。

优点

1. 提高代码的复用性：多态性允许使用父类类型的引用来引用子类对象，从而可以使用相同的代码来处理不同的对象类型。

2. 增强程序的扩展性：当添加新的子类时，只要它实现了父类或接口的规范，就可以无缝地集成到现有的代码中，而无需修改现有代码。

3. 解耦：多态性解耦了代码中各个部分的依赖关系，提高了系统的可维护性和可扩展性。

4. 提高灵活性：多态性使得程序能够根据不同的对象类型执行不同的操作，从而提高了程序的灵活性。

示例

以下是一个简单的Java示例，展示了多态性的应用：

java复制代码

	class Animal {
	void makeSound() {
	System.out.println("Some sound");
	}
	}
	class Dog extends Animal {
	@Override
	void makeSound() {
	System.out.println("Woof!");
	}
	}
	class Cat extends Animal {
	@Override
	void makeSound() {
	System.out.println("Meow!");
	}
	}
	public class TestPolymorphism {
	public static void main(String[] args) {
	Animal myDog = new Dog();
	Animal myCat = new Cat();
	myDog.makeSound(); // 输出: Woof!
	myCat.makeSound(); // 输出: Meow!
	}
	}

在这个示例中，Animal是一个抽象基类，Dog和Cat是Animal的子类，并且都重写了makeSound方法。在main方法中，我们使用了Animal类型的引用来引用Dog和Cat对象，并调用了它们的makeSound方法。由于多态性的存在，makeSound方法的实际行为取决于对象的实际类型（即Dog或Cat），而不是引用变量的类型（Animal）。

综上所述，多态性是面向对象编程中一个非常重要的特性，它提高了代码的复用性、扩展性和灵活性。

集合是计算机科学和数学中的一个重要概念，尤其在Java等编程语言中，集合框架（Java Collections Framework, JCF）是表示和操作集合的统一标准体系结构。以下是对集合的详细讲解：

一、集合的概念

1. 定义：
   • 集合是数学中的一个基本概念，指的是由一些确定的、不同的元素所组成的整体。
   • 在计算机科学中，集合通常被用作数据结构的基础，用于存储和操作一组元素。
2. 特性：
   • 无序性：某些集合（如Set）中的元素是无序的，即元素的存储和检索顺序可能与添加顺序不一致。
   • 唯一性：集合中的元素是唯一的，不允许有重复的元素（在Set中）。
   • 动态性：集合的大小是动态的，可以在运行时添加或删除元素。

二、Java集合框架

Java集合框架是Java编程中不可或缺的一部分，它提供了一组用于存储和操作数据的类和接口。

1. 主要内容：
   • 接口：代表集合的抽象数据类型，如List、Set、Map等。
   • 实现：接口的具体实现类，如ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等。
   • 算法：对集合进行操作的算法，如排序、查找、遍历等。
2. 核心接口与类：
   • Collection：是所有单列集合的根接口，其子接口包括List和Set。
     • List：有序集合（元素有序、可重复）。主要实现类有ArrayList、LinkedList和Vector。
       • ArrayList：基于数组实现，查询快，增删慢。
       • LinkedList：基于链表实现，增删快，查询慢。
       • Vector：基于数组实现，线程安全，但性能较低，已被ArrayList取代。
     • Set：无序集合（元素无序、不重复）。主要实现类有HashSet、LinkedHashSet和TreeSet。
       • HashSet：基于哈希表实现，插入和查找速度快。
       • LinkedHashSet：继承自HashSet，同时维护了一个双向链表来记录插入顺序。
       • TreeSet：基于红黑树实现，元素按自然顺序或自定义比较器排序。
   • Map：双列集合（键值对集合），主要实现类有HashMap、LinkedHashMap、TreeMap和Hashtable。
     • HashMap：基于哈希表实现，插入和查找速度快。
     • LinkedHashMap：继承自HashMap，同时维护了一个双向链表来记录插入顺序。
     • TreeMap：基于红黑树实现，元素按键的自然顺序或自定义比较器排序。
     • Hashtable：线程安全的Map实现，但性能较低，已被ConcurrentHashMap取代。
3. 迭代器（Iterator）：
   • 迭代器是遍历集合的专用方式，它提供了一种统一的方法来遍历不同类型的集合。
   • 使用迭代器可以隐藏底层集合的实现细节，使得遍历操作更加简单和通用。
4. 增强for循环：
   • Java 5引入了增强for循环（也称为for-each循环），它提供了一种更简洁的方式来遍历集合和数组。
   • 增强for循环的底层实现仍然是迭代器，但它隐藏了迭代器的复杂性，使得代码更加简洁易读。

三、集合与数组的比较

1. 类型：
   • 数组中的元素可以是基本数据类型或对象类型（实际上是对象的引用）。
   • 集合中只能保存对象（实际上是对象的引用）。
2. 长度：
   • 数组的长度是固定的，一旦创建就不能改变。
   • 集合的长度是动态的，可以根据需要添加或删除元素。
3. 访问方式：
   • 数组通过下标访问元素，访问速度较快。
   • 集合通常通过迭代器或增强for循环遍历元素，访问速度取决于集合的具体实现。
4. 功能：
   • 数组提供了基本的存储和访问功能，但不支持动态扩容或复杂的操作（如排序、查找等）。
   • 集合框架提供了丰富的接口和类，支持动态扩容、排序、查找等多种操作。

综上所述，集合是计算机科学中的一个重要概念，Java集合框架为Java编程提供了强大的数据结构和算法支持。在实际开发中，合理选择和使用集合框架可以显著提高程序的性能和可维护性。