GitHub Copilot
已使用 1 个引用
类
对象
封装
继承
多态
抽象类
接口
构造函数
方法重载
方法重写
访问修饰符
静态成员
静态方法
静态块
内部类
匿名内部类
抽象方法
接口实现
接口继承
多重继承
多态性
方法引用
构造器引用
this关键字
super关键字
final关键字
instanceof操作符
包
导入包
异常处理
序列化
反序列化
克隆
深拷贝
浅拷贝
单例模式
工厂模式
抽象工厂模式
代理模式
适配器模式
用法
类：
用法：定义对象的蓝图，包含属性和方法。
示例：
public class Person { private String name; private int age; public void setName(String name) { this.name = name; } public String getName() { return name; } }
对象：
用法：类的实例，通过类创建对象。
示例：
Person person = new Person(); person.setName("John");
封装：
用法：通过访问修饰符控制对类成员的访问，保护数据。
示例：
public class Person { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }
继承：
用法：一个类继承另一个类，获得其属性和方法。
示例：
public class Animal { public void eat() { System.out.println("This animal eats food."); } } public class Dog extends Animal { public void bark() { System.out.println("The dog barks."); } }
多态：
用法：同一方法在不同对象上有不同表现。
示例：
Animal animal = new Dog(); animal.eat(); // 调用的是Dog类中的eat方法
抽象类：
用法：不能实例化的类，包含抽象方法，必须由子类实现。
示例：
public abstract class Animal { public abstract void makeSound(); } public class Dog extends Animal { public void makeSound() { System.out.println("Bark"); } }
接口：
用法：定义一组方法，类实现接口必须实现这些方法。
示例：
public interface Animal { void makeSound(); } public class Dog implements Animal { public void makeSound() { System.out.println("Bark"); } }
构造函数：
用法：初始化对象时调用的方法。
示例：
public class Person { private String name; public Person(String name) { this.name = name; } }
方法重载：
用法：同一类中多个方法同名但参数不同。
示例：
public class MathUtils { public int add(int a, int b) { return a + b; } public double add(double a, double b) { return a + b; } }
方法重写：
用法：子类重新定义父类的方法。
示例：
public class Animal { public void makeSound() { System.out.println("Animal sound"); } } public class Dog extends Animal { @Override public void makeSound() { System.out.println("Bark"); } }
访问修饰符：
用法：控制类、方法和属性的访问级别。
示例：
public class Person { private String name; // 仅类内部可访问 public int age; // 任何地方可访问 }
静态成员：
用法：属于类而不是实例的变量或方法。
示例：
public class MathUtils { public static final double PI = 3.14159; }
静态方法：
用法：属于类而不是实例的方法。
示例：
public class MathUtils { public static int add(int a, int b) { return a + b; } }
静态块：
用法：用于初始化静态变量。
示例：
public class MathUtils { static { System.out.println("Static block executed"); } }
内部类：
用法：定义在另一个类内部的类。
示例：
public class OuterClass { class InnerClass { void display() { System.out.println("Inner class"); } } }
匿名内部类：
用法：没有名字的内部类，通常用于简化代码。
示例：
public class Test { public static void main(String[] args) { new Thread(new Runnable() { public void run() { System.out.println("Anonymous inner class"); } }).start(); } }
抽象方法：
用法：没有实现的方法，必须由子类实现。
示例：
public abstract class Animal { public abstract void makeSound(); }
接口实现：
用法：类实现接口并提供接口方法的具体实现。
示例：
public class Dog implements Animal { public void makeSound() { System.out.println("Bark"); } }
接口继承：
用法：一个接口继承另一个接口。
示例：
public interface Animal { void makeSound(); } public interface Pet extends Animal { void play(); }
多重继承：
用法：通过接口实现多重继承。
示例：
public interface Animal { void makeSound(); } public interface Pet { void play(); } public class Dog implements Animal, Pet { public void makeSound() { System.out.println("Bark"); } public void play() { System.out.println("Play"); } }
多态性：
用法：同一方法在不同对象上有不同表现。
示例：
Animal animal = new Dog(); animal.makeSound(); // 调用的是Dog类中的makeSound方法
方法引用：
用法：使用现有的方法来实现函数式接口的抽象方法。
示例：
List<String> list = Arrays.asList("a", "b", "c"); list.forEach(System.out::println);
构造器引用：
用法：使用构造器来实现函数式接口的抽象方法。
示例：
Supplier<List<String>> listSupplier = ArrayList::new; List<String> list = listSupplier.get();
this关键字：
用法：引用当前对象。
示例：
public class Person { private String name; public Person(String name) { this.name = name; } }
super关键字：
用法：引用父类对象。
示例：
public class Animal { public void makeSound() { System.out.println("Animal sound"); } } public class Dog extends Animal { public void makeSound() { super.makeSound(); System.out.println("Bark"); } }
final关键字：
用法：用于声明常量、方法不可重写、类不可继承。
示例：
public final class Constants { public static final double PI = 3.14159; }
instanceof操作符：
用法：检查对象是否是特定类的实例。
示例：
if (obj instanceof String) { System.out.println("obj is a String"); }
包：
用法：组织类和接口的命名空间。
示例：
package com.example; public class MyClass { }
导入包：
用法：在类中使用其他包中的类和接口。
示例：
import java.util.List; public class MyClass { }
异常处理：
用法：处理程序运行时的异常情况。
示例：
try { int result = 10 / 0; } catch (ArithmeticException e) { System.out.println("Cannot divide by zero"); }
序列化：
用法：将对象转换为字节流以便存储或传输。
示例：
public class Person implements Serializable { private static final long serialVersionUID = 1L; private String name; }
反序列化：
用法：将字节流转换回对象。
示例：
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser")); Person person = (Person) ois.readObject();
克隆：
用法：创建对象的副本。
示例：
public class Person implements Cloneable { protected Object clone() throws CloneNotSupportedException { return super.clone(); } }
深拷贝：
用法：创建对象及其引用对象的副本。
示例：
public class Person implements Cloneable { private Address address; protected Object clone() throws CloneNotSupportedException { Person cloned = (Person) super.clone(); cloned.address = (Address) address.clone(); return cloned; } }
浅拷贝：
用法：创建对象的副本，但不复制引用对象。
示例：
public class Person implements Cloneable { protected Object clone() throws CloneNotSupportedException { return super.clone(); } }
单例模式：
用法：确保一个类只有一个实例，并提供全局访问点。
示例：
public class Singleton { private static Singleton instance; private Singleton() { } public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } }
工厂模式：
用法：定义一个创建对象的接口，但让子类决定实例化哪个类。
示例：
public interface Shape { void draw(); } public class Circle implements Shape { public void draw() { System.out.println("Circle"); } } public class ShapeFactory { public Shape getShape(String shapeType) { if (shapeType.equals("CIRCLE")) { return new Circle(); } return null; } }
抽象工厂模式：
用法：提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。
示例：
public interface Shape { void draw(); } public class Circle implements Shape { public void draw() { System.out.println("Circle"); } } public interface AbstractFactory { Shape getShape(String shapeType); } public class ShapeFactory implements AbstractFactory { public Shape getShape(String shapeType) { if (shapeType.equals("CIRCLE")) { return new Circle(); } return null; } }
代理模式：
用法：为其他对象提供一种代理以控制对这个对象的访问。
示例：
public interface Image { void display(); } public class RealImage implements Image { private String fileName; public RealImage(String fileName) { this.fileName = fileName; } public void display() { System.out.println("Displaying " + fileName); } } public class ProxyImage implements Image { private RealImage realImage; private String fileName; public ProxyImage(String fileName) { this.fileName = fileName; } public void display() { if (realImage == null) { realImage = new RealImage(fileName); } realImage.display(); } }
适配器模式：
用法：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
示例：
public interface MediaPlayer { void play(String audioType, String fileName); } public class AudioPlayer implements MediaPlayer { public void play(String audioType, String fileName) { if (audioType.equalsIgnoreCase("mp3")) { System.out.println("Playing mp3 file. Name: " + fileName); } } } public interface AdvancedMediaPlayer { void playVlc(String fileName); void playMp4(String fileName); } public class VlcPlayer implements AdvancedMediaPlayer { public void playVlc(String fileName) { System.out.println("Playing vlc file. Name: " + fileName); } public void playMp4(String fileName) { // Do nothing } } public class MediaAdapter implements MediaPlayer { AdvancedMediaPlayer advancedMusicPlayer; public MediaAdapter(String audioType) { if (audioType.equalsIgnoreCase("vlc")) { advancedMusicPlayer = new VlcPlayer(); } } public void play(String audioType, String fileName) { if (audioType.equalsIgnoreCase("vlc")) { advancedMusicPlayer.playVlc(fileName); } } }