项目开发笔记-3

// 1. 参数与成员变量同名时使用this
public void setName(String name) {
    this.name = name;		// 消除命名歧义必须使用this
}

// 2. 构造方法重载时使用this()
public Person(String name) {
    this(name, 0);		// 构造方法重载，避免代码重复
}

// 3. 方法链式调用返回this
public Builder setValue(String value) {
    this.value = value;
    return this;		// 链式调用，提供流畅API
}

// 4. 提高代码可读性
public void process() {
    this.scan();		// 明确表示当前对象操作
    this.execute();
  	this.print();
}

// 一些例子
String str1 = "Hello";
String str2 = "Hello";	// 字面量创建，效率最高
String str3 = new String("Java");		// 创建新对象，效率较低
String str4 = new String("Java");

System.out.println(str1 == str2);		// true 字面量创建的String指向同一个对象
System.out.println(str3 == str4); 	// false
System.out.println(str3.equals(str4));	//true
System.out.println(str3.equalsIgnoreCase(str4));	// 忽略大小写
int compareRes = str2.compareTo(str3);	// 比较长度

// 获取长度
int length = text.length();

// 安全的判空方法
if (text != null && !text.isEmpty()) {
  System.out.println("The string is not blank");
}

// 查找字符和子串
int idx1 = text.indexOf('e');		// 首个出现位置
int idx2 = text.indexOf("Apple");	// 首个子串出现位置的首位下标
int idx3 = text.lastIndexOf('e');	// 最后出现位置

// 包含判断
boolean contains = text.contains("World"); // true
boolean startsWith = text.startsWith("Hello"); // true
boolean endsWith = text.endsWith("World"); // true

public class Animal {
	protect String name;
  protect String species;
  
  public Animal(String name, String species) {
  		this.name = name;
    	this.species = species;
  }
  
  public void makeSound() {
    	System.out.println(name + "is making sounds.")
  }
  
}

public class Cat extends Animal {
  // 采用extends关键字来表示继承
  // final修饰的类不能被继承(e.g., String类)
  
  private String breed;
  
  
  // 创建子类对象时，会先调用父类构造方法，再调用子类构造方法
  public Cat(String name, String breed) {
    	// 如果父类没有无参构造方法
    	// 子类必须在构造方法的第一行显式调用父类的有参构造方法
    	super(name, "felines");
    	this.breed = breed;
  }
  
  // 重写父类中的方法
  // 重写方法的访问修饰符可以更宽松，但不能更严格
  // 重写方法的方法名和参数列表完全相同，返回类型可以是父类方法返回类型的子类
  // Object类是所有类的根父类
  @Override
  public void makeSound() {
    	System.out.Println(name + " Meow.")
  }
  
}

abstract class Shape {
    protected String color;
    protected String name;
    
  	// 构造方法 
    public Shape(String name, String color) {
        this.name = name;
        this.color = color;
    }
    
    // 抽象方法：计算面积
  	// 在不同的图形子类中可以有不同的实现
    public abstract double calculateArea();
    
    // 抽象方法：计算周长
    public abstract double calculatePerimeter();
    
    // 具体方法：显示图形信息
    public void displayInfo() {
        System.out.println("Graphics: " + name);
        System.out.println("Color: " + color);
        System.out.println("Area: " + String.format("%.2f", calculateArea()));
        System.out.println("Perimeter: " + String.format("%.2f", calculatePerimeter()));
    }
}

interface Collection {
    void add(Object item);
    void remove(Object item);
    int size();
    
    // 默认方法
    default boolean isEmpty() {
        return size() == 0;
    }
    
    default void clear() {
        // 默认的清空实现
        while (!isEmpty()) {
            // 需要子类提供具体的移除逻辑
        }
    }
}

public interface Interface1 {
  // public static final
  int CONSTANT = 6;
  
  // public abstract
  int method1();
  void method2();
}

// 多重继承
public class MyClass implements Interface1, Interface2 {
  @Override
  public int method1() {
    	// 实现interface1中的方法
  }
  
  @Override
  public void method2() {
    // 实现interface1中的方法
  }
  
  @Override 
  public void method3() {
    // 实现interface2中的方法
  }
}

// 静态多态: 方法重载Overloading, 运算符重载，编译时确定
public void print(int num) {}
public void print(String str) {}
public void print(boolean flag) {}


// 动态多态：方法重写Overriding, 动态绑定，运行时确认调用哪个方法
@Override 
public void makeSound() {
  System.out.println("Meow");
}

// 向上转型: 将子类对象复制给父类引用
Animal animal = new Dog("旺财", 3, "金毛");  // 自动向上转型

// 特点：
// 1. 自动进行，无需强制转换
// 2. 只能访问父类中定义的方法
// 3. 实际调用的是子类重写的方法（动态绑定）
animal.makeSound();  // 调用Dog重写的makeSound方法
animal.move();       // 调用Dog重写的move方法
// animal.wagTail(); // 编译错误！无法访问子类特有方法

// 向下转型: 将父类引用转化为子类引用
Animal animal = new Dog("旺财", 3, "金毛");

// 安全的向下转型
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;  // 强制转换
    dog.wagTail();           // 现在可以调用子类特有方法
    dog.guard();
}

// 错误示例（会抛出ClassCastException）
// Cat cat = (Cat) animal;  // 运行时异常！

public class Outer {
    private int value = 10;
    
    public class Inner {
	      private int innerVal = 42;
        public void print() {
            System.out.println(value); // 直接访问外部类字段
          	// 可以通过Outer.this.value访问
        }
    }
}

public class OuterClass {
    private static String staticField = "外部类静态字段";
    private String instanceField = "外部类实例字段";
    
    // 静态嵌套类
    public static class NestedClass {
        private String nestedField = "嵌套类字段";
        
        public void nestedMethod() {
            // 可以访问外部类的静态成员
            System.out.println(staticField);
            
            // 不能直接访问外部类的实例成员
            // System.out.println(instanceField); // 编译错误
            
            System.out.println(nestedField);
        }
    }
}

// 独立于外部类对象，直接创建静态嵌套类对象
OuterClass.NestedClass nested = new OuterClass.NestedClass();
nested.nestedMethod();

public class ScopeComparison {
    private String outerField = "outer";
    
    // 成员内部类 - 类级别作用域
    class MemberInner {
        // 在整个外部类中可见
    }
    
    public void demonstrateScopes() {
        String localVar = "local";
        
        // 局部内部类 - 方法级别作用域
        class LocalInner {
            public void show() {
                System.out.println(outerField); // 可以访问外部类字段
                System.out.println(localVar);   // 可以访问final局部变量
            }
        }
        
        LocalInner inner = new LocalInner();
        inner.show();
        
        // 局部内部类只在当前方法中可见
        // 外部无法访问：LocalInner inner2 = new LocalInner(); // 编译错误
    }
    
    public void anotherMethod() {
        // 这里无法访问LocalInner类
        // LocalInner inner = new LocalInner(); // 编译错误
    }
}

// 定义接口
interface Greeting {
    void sayHello(String name);
    void sayGoodbye(String name);
}

public class AnonymousDemo {
    public static void main(String[] args) {
        // 创建匿名类实现接口
        Greeting greeting = new Greeting() {
            private int count = 0;
            
            @Override
            public void sayHello(String name) {
                count++;
                System.out.println("你好, " + name + "! (第" + count + "次问候)");
            }
            
            @Override
            public void sayGoodbye(String name) {
                System.out.println("再见, " + name + "!");
            }
            
            // 可以添加额外的方法（但外部无法调用）
            public void internalMethod() {
                System.out.println("内部方法");
            }
        };
        
        greeting.sayHello("张三");
        greeting.sayHello("李四");
        // greeting.internalMethod(); // 编译错误 - 只能访问接口定义的方法
    }
}

// 最基本的枚举 Day.SUNDAY
public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, 
    THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

// 带有属性的枚举
public enum Color {
    RED("红色", "#FF0000"),
    GREEN("绿色", "#00FF00"),
    BLUE("蓝色", "#0000FF");
    
    private final String name;
    private final String code;
    
    Color(String name, String code) {
        this.name = name;
        this.code = code;
    }
}

// 带方法的枚举
public enum Operation {
    PLUS("+") {
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS("-") {
        public double apply(double x, double y) {
            return x - y;
        }
    };
    
    public abstract double apply(double x, double y);
}

// 没有泛型的情况
List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0); // 需要强制类型转换

// 使用泛型
List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // 自动类型转换，不需要强制转换

// ❌ 没有泛型 - 运行时可能出错
List list = new ArrayList();
list.add("字符串");
list.add(123); // 编译通过，但运行时可能出问题

// ✅ 使用泛型 - 编译时就能发现错误
List<String> stringList = new ArrayList<>();
stringList.add("字符串");
// stringList.add(123); // 编译错误！无法添加整数

// 传统方式
List list = new ArrayList();
list.add("hello");
Object obj = list.get(0);
String str = (String) obj; // 需要强制转换

// 泛型方式
List<String> list = new ArrayList<>();
list.add("hello");
String str = list.get(0); // 自动转换，无需强制转换

// 上界通配符 - 只能读取
public static double sum(List<? extends Number> numbers) {
    double total = 0.0;
    for (Number num : numbers) {
        total += num.doubleValue(); // 只能读取
    }
    return total;
}

// 下界通配符 - 只能写入
public static void addNumbers(List<? super Integer> numbers) {
    numbers.add(1); // 只能写入Integer或其子类
    numbers.add(2);
    numbers.add(3);
}

// 无界通配符 - 类型无关操作
public static int getSize(List<?> list) {
    return list.size(); // 只能进行与类型无关的操作
}