七、构造方法
7.1 构造方法基础
public class ConstructorDemo {
private String name;
private int age;
// 1. 无参构造器
public ConstructorDemo() {
this.name = "默认";
this.age = 0;
}
// 2. 有参构造器
public ConstructorDemo(String name) {
this.name = name;
this.age = 0;
}
// 3. 全参构造器
public ConstructorDemo(String name, int age) {
this.name = name;
this.age = age;
}
// 4. 私有构造器（单例模式、工具类）
private ConstructorDemo(int id) {
// 私有构造器
}
// 5. 拷贝构造器
public ConstructorDemo(ConstructorDemo other) {
this.name = other.name;
this.age = other.age;
}
}
7.2 构造器链
public class ConstructorChainDemo {
private String a;
private String b;
private String c;
// 使用this()调用其他构造器
public ConstructorChainDemo() {
this("默认A"); // 必须放在第一行
}
public ConstructorChainDemo(String a) {
this(a, "默认B");
}
public ConstructorChainDemo(String a, String b) {
this(a, b, "默认C");
}
public ConstructorChainDemo(String a, String b, String c) {
this.a = a;
this.b = b;
this.c = c;
}
}
// 构建器模式（替代多参数构造器）
public class Person {
private final String name;
private final int age;
private final String email;
private Person(Builder builder) {
this.name = builder.name;
this.age = builder.age;
this.email = builder.email;
}
public static class Builder {
private String name;
private int age;
private String email;
public Builder name(String name) {
this.name = name;
return this;
}
public Builder age(int age) {
this.age = age;
return this;
}
public Builder email(String email) {
this.email = email;
return this;
}
public Person build() {
return new Person(this);
}
}
// 使用示例
public static void main(String[] args) {
Person person = new Person.Builder()
.name("张三")
.age(25)
.email("zhang@example.com")
.build();
}
}
八、方法重写
8.1 重写规则
方法重写（Overriding）：子类重新实现父类的方法。
重写规则：
方法名、参数列表必须相同
返回值类型必须是父类返回类型的子类型（协变返回）
访问修饰符不能比父类更严格
不能重写final方法
不能重写静态方法（隐藏而非重写）
class Animal {
public String sound() {
return "动物发出声音";
}
protected Animal getInstance() {
return new Animal();
}
public final void cannotOverride() {
System.out.println("不能被重写");
}
public static void staticMethod() {
System.out.println("父类静态方法");
}
}
class Dog extends Animal {
// 重写父类方法
@Override
public String sound() {
return "汪汪汪";
}
// 协变返回类型
@Override
public Dog getInstance() {
return new Dog();
}
// 无法重写final方法
// 方法隐藏（不是重写）
public static void staticMethod() {
System.out.println("子类静态方法");
}
}
8.2 @Override注解
public class OverrideAnnotationDemo {
// @Override的作用：
// 1. 编译时检查是否正确重写
// 2. 提高代码可读性
class Parent {
public void method1() {}
public void method2() {}
}
class Child extends Parent {
@Override
public void method1() {} // 正确重写
// @Override
// public void method3() {} // 编译错误：没有重写任何方法
@Override
public void method2() {} // 正确重写
}
}
九、抽象方法与接口方法
9.1 抽象方法
// 抽象类
public abstract class Shape {
// 抽象方法：没有方法体
public abstract double area();
public abstract double perimeter();
// 抽象类可以有具体方法
public void display() {
System.out.println("面积: " + area());
System.out.println("周长: " + perimeter());
}
}
// 具体子类必须实现所有抽象方法
class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
@Override
public double perimeter() {
return 2 * Math.PI * radius;
}
}
class Rectangle extends Shape {
private double width;
private double height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public double area() {
return width * height;
}
@Override
public double perimeter() {
return 2 * (width + height);
}
}
9.2 接口方法
// 接口中的方法（Java 8+）
public interface MyInterface {
// 1. 抽象方法（默认public abstract）
void abstractMethod();
// 2. 默认方法（Java 8）
default void defaultMethod() {
System.out.println("默认方法");
privateMethod(); // 可以调用私有方法
}
// 3. 静态方法（Java 8）
static void staticMethod() {
System.out.println("静态方法");
}
// 4. 私有方法（Java 9）
private void privateMethod() {
System.out.println("私有方法");
}
// 5. 私有静态方法（Java 9）
private static void privateStaticMethod() {
System.out.println("私有静态方法");
}
}
// 函数式接口（只有一个抽象方法）
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
// 可以有多个默认方法
default void log() {
System.out.println("计算完成");
}
// 可以有多个静态方法
static Calculator add() {
return (a, b) -> a + b;
}
static Calculator multiply() {
return (a, b) -> a * b;
}
}
