脚踏实地

// 面向过程编程示例：计算矩形面积

public class ProceduralExample {
    // 定义计算面积的函数
    public static int calculateArea(int width, int height) {
        return width * height;
    }

    public static void main(String[] args) {
        int width = 5;
        int height = 10;
        int area = calculateArea(width, height);
        System.out.println("矩形的面积是: " + area);
    }
}

// 面向对象编程示例：计算矩形面积

// 定义矩形类
class Rectangle {
    private int width;
    private int height;

    // 构造函数
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    // 计算面积的方法
    public int calculateArea() {
        return width * height;
    }
}

public class ObjectOrientedExample {
    public static void main(String[] args) {
        // 创建矩形对象
        Rectangle rectangle = new Rectangle(5, 10);
        // 调用对象的方法计算面积
        int area = rectangle.calculateArea();
        System.out.println("矩形的面积是: " + area);
    }
}

public class MainTest {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.running("汽车");
        // 飞机不是在路上行驶
        vehicle.running("飞机");
    }
}

/**
 * 在run方法中违反了单一职责原则
 * 解决方法根据不同的交通工具,分解成不同的类即可
 */
class Vehicle{
    public void running(String name) {
        System.out.println(name + "在路上行驶 ....");
    }
}

// 解决
public class MainTest {
    public static void main(String[] args) {
        Driving driving = new Driving();
        driving.running("汽车");
        Flight flight = new Flight();
        flight.running("飞机");
    }
}

class Driving {
    public void running(String name) {
        System.out.println(name + "在路上行驶 ....");
    }
}

class Flight {
    public void running(String name) {
        System.out.println(name + "在空中飞行 ....");
    }
}

public class MainTest {
    public static void main(String[] args) {
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.driving("汽车");
        vehicle2.flight("飞机");
    }
}
/*
 * 改进
 *↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
 */

class Vehicle2 {
    public void driving(String name) {
        System.out.println(name + "在路上行驶 ....");
    }
    public void flight(String name) {
        System.out.println(name + "在空中飞行 ....");
    }
}

public class MainTest {
    public static void main(String[] args) {
        Mother mother = new Mother();

        Son son = new Son();
        Daughter daughter = new Daughter();

        // 注入子类对象 如果扩展需要其他类 换成其他对象即可
        mother.setAbstractFather(son);
        mother.display();
    }
}

abstract class AbstractFather {

    protected abstract void display();

}
class Son  extends AbstractFather{
    @Override
    protected void display() {
        System.out.println("son class ...");
    }
}
class Daughter  extends AbstractFather{

    @Override
    protected void display() {
        System.out.println("daughter class ...");
    }
}

class Mother {

    private AbstractFather abstractFather;

    public void setAbstractFather(AbstractFather abstractFather) {
        this.abstractFather = abstractFather;
    }

    public void display() {
        abstractFather.display();
    }

}

// 定义一个接口，表示消息发送者
interface MessageSender {
    void sendMessage(String message);
}

// 实现接口的EmailSender类
class EmailSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending email with message: " + message);
    }
}

// 实现接口的SmsSender类
class SmsSender implements MessageSender {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending SMS with message: " + message);
    }
}

// 高层模块的MessageService类依赖于MessageSender接口
class MessageService {
    private MessageSender sender;

    // 通过构造函数注入依赖
    public MessageService(MessageSender sender) {
        this.sender = sender;
    }

    public void processMessage(String message) {
        // 使用MessageSender接口发送消息
        sender.sendMessage(message);
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用EmailSender发送消息
        MessageSender emailSender = new EmailSender();
        MessageService emailService = new MessageService(emailSender);
        emailService.processMessage("Hello via Email!");

        // 使用SmsSender发送消息
        MessageSender smsSender = new SmsSender();
        MessageService smsService = new MessageService(smsSender);
        smsService.processMessage("Hello via SMS!");
    }
}

public class MainTest {
    public static void main(String[] args) {
        FuncImpl func = new FuncImpl();
        func.func1();
        func.func2();
        func.func3();
    }
}

interface Function1{
    void func1();
    // 如果将接口中的方法都写在一个接口就会造成实现该接口就要重写该接口所有方法。
    // 当然Java 8 接口可以有实现，降低了维护成本，解了决该问题；
    // 但是我们还是应当遵循该原则，使得接口看起来更加清晰
    // void func2();
    // void func3();
}
interface Function2 {
    void func2();
}
interface Function3 {
    void func3();
}

class FuncImpl implements Function1,Function2,Function3{

    @Override
    public void func1() {
        System.out.println("i am function1 impl");
    }

    @Override
    public void func2() {
        System.out.println("i am function2 impl");
    }

    @Override
    public void func3() {
        System.out.println("i am function3 impl");
    }
}

public class MainTest {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(20);
        rectangle.setHeight(10);
        resize(rectangle);
        print(rectangle);
        System.out.println("=======================");
        Rectangle square = new Square();
        square.setWidth(10);
        // 因为 Square类 重写了父类 setWidth setHeight 方法，会导致 while 循环变成一个无限循环
        resize(square);
        print(square);
    }
    public static void resize(Rectangle rectangle){
        while (rectangle.getWidth() >= rectangle.getHeight()){
            rectangle.setHeight(rectangle.getHeight() + 1);
        }
    }

    public static void print(Rectangle rectangle){
        System.out.println(rectangle.getWidth());
        System.out.println(rectangle.getHeight());
    }
}

// 正方形
class Square  extends Rectangle{

    @Override
    public void setWidth(Integer width) {
        super.setWidth(width);
        super.setHeight(width);
    }

    @Override
    public void setHeight(Integer height) {
        super.setWidth(height);
        super.setHeight(height);
    }
}

// 长方形
class Rectangle {
    private Integer width;
    private Integer height;

    public void setWidth(Integer width) {
        this.width = width;
    }

    public void setHeight(Integer height) {
        this.height = height;
    }

    public Integer getWidth() {
        return width;
    }

    public Integer getHeight() {
        return height;
    }
}

// 引擎接口
interface Engine {
    void start();
}

// 电动引擎
class ElectricEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Electric engine starts...");
    }
}

// 燃油引擎
class GasEngine implements Engine {
    @Override
    public void start() {
        System.out.println("Gas engine starts...");
    }
}

// 汽车类
class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
        System.out.println("Car starts...");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建一个电动引擎汽车
        Engine electricEngine = new ElectricEngine();
        Car electricCar = new Car(electricEngine);
        electricCar.start();

        System.out.println("=======================");

        // 创建一个燃油引擎汽车
        Engine gasEngine = new GasEngine();
        Car gasCar = new Car(gasEngine);
        gasCar.start();
    }
}

// 学生类
class Student {
    private String name;
    private Class myClass;

    public Student(String name, Class myClass) {
        this.name = name;
        this.myClass = myClass;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 查询自己的班级信息
    public void queryClassInfo() {
        String className = myClass.getClassName();
        System.out.println(name + " is in class " + className);
    }
}

// 班级类
class Class {
    private String className;

    public Class(String className) {
        this.className = className;
    }

    public String getClassName() {
        return className;
    }
}

// 老师类
class Teacher {
    private String name;

    public Teacher(String name) {
        this.name = name;
    }

    // 不符合迪米特法则的方法示例，直接返回班级名
    // public String getStudentClass(Student student) {
    //     return student.myClass.getClassName();
    // }

    // 通过学生对象调用公共方法获取班级信息
    public String getStudentClass(Student student) {
        return student.queryClassInfo();
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建班级
        Class class1 = new Class("Class 1");

        // 创建学生并设置班级
        Student student = new Student("Alice", class1);

        // 学生查询自己的班级信息
        student.queryClassInfo();

        System.out.println("=======================");

        // 创建老师并查询学生的班级信息
        Teacher teacher = new Teacher("Mr. Smith");
        String studentClass = teacher.getStudentClass(student);
        System.out.println(student.getName() + " is in class " + studentClass);
    }
}

public class AccessExample {
    public String id;
    // public int id;
}

public class AccessExample {

    private int id;

    public String getId() {
        return id + "";
    }

    public void setId(String id) {
        this.id = Integer.valueOf(id);
    }
}

public class AccessWithInnerClassExample {

    private class InnerClass {
        int x;
    }

    private InnerClass innerClass;

    public AccessWithInnerClassExample() {
        innerClass = new InnerClass();
    }

    public int getValue() {
        return innerClass.x;  // 直接访问
    }
}

// 继承
public class MainTest {

    public static void main(String[] args) {
        B b = new B();
        b.test();
    }
}

class A {

    protected int i;

    protected void test() {
        System.out.println("I am super class ... ");
    }

}

class B  extends A{

    // 调用父类成员 
    public void t() {
        System.out.println(super.i);
    }

}

public class MainTest {

    public static void main(String[] args) {
        B b = new B(new A());
        b.test();
    }
}

class A {

    protected int i;

    protected void test() {
        System.out.println("I am super class ... ");
    }

}

class B {

    private final A a;

    public B(A a) {
        this.a = a;
    }
    public void test() {
        // 复用 A 类提供的 test 方法
        a.test();
    }
}

public abstract class AbstractClassExample {

    protected int x;
    private int y;

    public abstract void func1();

    public void func2() {
        System.out.println("func2");
    }
}
public class AbstractExtendClassExample extends AbstractClassExample {
    @Override
    public void func1() {
        System.out.println("func1");
    }
}

// 实例化抽象类
// AbstractClassExample ac1 = new AbstractClassExample(); 
// 实例化抽象类子类
// AbstractClassExample ac2 = new AbstractExtendClassExample();
// ac2.func1();

public interface InterfaceExample {

    void func1();

    default void func2(){
        System.out.println("func2");
    }

    int x = 123;
    // int y;               // Variable 'y' might not have been initialized
    public int z = 0;       // Modifier 'public' is redundant for interface fields
    // private int k = 0;   // Modifier 'private' not allowed here
    // protected int l = 0; // Modifier 'protected' not allowed here
    // private void fun3(); // Modifier 'private' not allowed here
}
public class InterfaceImplementExample implements InterfaceExample {
    @Override
    public void func1() {
        System.out.println("func1");
    }
}

interface Action extends Serializable,AutoCloseable {
	// to do ...
}

class Parent {

    void contextLoads(){
        System.out.println("i am Parent ... ");
    }
}
class Child  extends Parent {
    @Override
    void contextLoads(){
        System.out.println("i am Child ... ");
    }
}
class mainTest{
    public static void main(String[] args) {
        Parent child = new Child();
        // i am Child ... 
        child.contextLoads();
    }
}

class Parent {
    void contextLoads(){
        System.out.println("i am Parent ... ");
    }
}
class Child  extends Parent {

    String  c = "child";

    @Override
    void contextLoads(){
        System.out.println("i am Child ... ");
    }
    void test() {
        System.out.println("i am test method ...");
    }
}
class mainTest{
    public static void main(String[] args) {
        Parent child = new Child();
        // 编译报错: 无法解析 'Parent' 中的方法 'test'
        child.test();
        // 编译报错: 不能解决符号 'c'
        child.c;
    }
}

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Cat meows");
    }
}

public class TestDynamicBinding {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.makeSound(); // 输出 "Dog barks"
        myCat.makeSound(); // 输出 "Cat meows"
    }
}

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

class Singleton {

    private Singleton() {}

    private static final Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
}

class Singleton {
    private Singleton() {
    }

    private static Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

class Singleton {

    /**
     * volatile在这作用: 禁止JVM指令重排
     */
    private static volatile Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

class Singleton {

    private Singleton() {}

    private static class InnerClass {
        private static final Singleton instance = new Singleton();
    }
    public static Singleton getInstance() {
        return InnerClass.instance;
    }
}

enum Singleton {
    INSTAMCE;

    Singleton() {
    }
}

public class Singleton implements Serializable{

    private volatile static Singleton singleton;
    
    private Singleton (){}
    
    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

    private Object readResolve() {
        return singleton;
    }
}

public class SimpleFactoryDemo {
    public static void main(String[] args) {
        SimpleFactory.getTest(1);
    }
}

class SimpleFactoryImpl1 implements SimpleFactoryInterface {

    @Override
    public void test() {
        System.out.println("i am  simpleFactory 1 ...");
    }
}
class SimpleFactoryImpl2 implements SimpleFactoryInterface {

    @Override
    public void test() {
        System.out.println("i am  simpleFactory 2 ...");
    }
}

class SimpleFactory {
    public static void getTest(int n) {
        switch (n) {
            case 1:
                SimpleFactoryImpl1 simpleFactory = new SimpleFactoryImpl1();
                simpleFactory.test();
                break;
            case 2:
                SimpleFactoryImpl2 simpleFactoryImpl2 = new SimpleFactoryImpl2();
                simpleFactoryImpl2.test();
                break;
            default:
        }
    }
}

public class FactoryMethodDemo {
    public static void main(String[] args) {
        FoodFactory f = new ColdRiceNoodleFactory();
        f.getFood().eat();
        // 扩展需要增加产品及相应产品工厂并实现相关接口
    }
}

interface Food {
    void eat();
}
interface FoodFactory {
    Food getFood();
}

class RiceNoodle implements Food{

    @Override
    public void eat() {
        System.out.println("eat rice noodle ...");
    }
}
class RiceNoodleFactory implements FoodFactory{

    @Override
    public Food getFood() {
        return new RiceNoodle();
    }
}

class ColdRiceNoodle implements Food {

    @Override
    public void eat() {
        System.out.println("eat cold rice noodle ...");
    }
}
class ColdRiceNoodleFactory implements FoodFactory {

    @Override
    public Food getFood() {
        return new ColdRiceNoodle();
    }
}