Pinch Java knowledge points by hand

Started object-oriented today

Object Oriented Basics

    类：由属性和行为组成
        属性：在类中通过成员变量来体现
        行为：在类中通过成员方法来体现
        public class 类名{
            //成员变量
            变量1的数据类型 变量1;
            变量2的数据类型 变量2;
            ...
            //成员方法
            方法1;
            方法2;
            ...
        }

There are several important concepts and features to understand.

classes and objects

在Java中，类是描述具有相同属性和行为的对象的蓝图。通过定义类，可以创建
多个实例，即对象。对象是类的具体实现，并且可以使用其属性和方法来完成特
定的任务。

encapsulation

封装是将数据和操作组合起来，以便通过类的接口访问它们。通过将数据字段隐
藏在类的内部，并提供公共方法来访问和修改数据，可以保护数据的完整性和安
全性。

inherit

继承是指一个类获得另一个类的属性和方法。通过继承，子类可以重用父类的代
码，并且还可以添加自己的特定功能。在Java中，使用关键字extends实现继承
关系。

polymorphism

多态是指一个对象可以表现出多种形态或类型。通过多态，可以使用统一的接
口来处理不同类型的对象，提高代码的可复用性和可拓展性。在Java中，多态
可以通过方法的重写和接口的实现来实现。

Abstract classes and interfaces

抽象类是无法被实例化的类，它可以包含抽象方法和非抽象方法。抽象方法只有
声明而没有具体实现，需要子类去实现。接口定义了一组方法的规范，任何类都
可以实现一个或多个接口。不同类之间通过继承抽象类或实现接口来共享代码
和行为。

besidesThere are also other concepts related to object orientation, such as constructors, method overloading, access modifiers, etc. It is also important to understand these basics.

code example

定义一个新的手机类并在这个类中使用。

public class crj {
    
    
    public static void main(String[] args) {
    
    
        Phone p = new Phone();
        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendPassage();
    }
}

新定义一个学生类，并在这个类中使用。

public class crj {
    
    
   public static void main(String[] args) {
    
    
       Student s = new Student();
       //调用成员变量
       s.name="高启强";
       s.age=39;
       System.out.println(s.name+s.age);
       //调用成员方法
       s.study();
       s.doHomework();
   }
}
public class Student {
    
    
   //成员变量
   String name;
   int age;
   //private int age;

   public void setAge(int a) {
    
    
//        age = a;
       if (a < 0 || a > 120) {
    
    
           System.out.println("年龄有误");
       } else {
    
    
           age = a;
       }
   }

   //成员方法
   public void study() {
    
    
       System.out.println("好好学习");
   }

   public void doHomework() {
    
    
       System.out.println("多加练习");
       int j = 0;
   }

   public void show() {
    
    
       System.out.println(name + "," + age);
   }
   public String getName(){
    
    
       return name;
   }
   public int getAge(){
    
    
       return age;
   }
}

private keyword

    是一个权限修饰符
    可以修饰成员
    作用：保护成员不被别的类使用，
            被private修饰的成员只在本类中才能访问
    使用方法
        提供get变量名()用于获取成员变量的值，方法用public修饰
           set变量名(参数)用于设置成员变量的值方法用public修饰


	在Java中，private是一种访问修饰符（access modifier），用于控制类
	的成员（字段和方法）的可见性。具体来说，private修饰的成员只能在所
	属类的内部访问，而在类的外部是不可见的。

	使用private关键字可以实现封装（encapsulation）的概念，将类的内部
	数据和实现细节隐藏起来，只暴露必要的接口给外部使用。这样做的好处是
	可以提高代码的安全性和可维护性，防止外部代码直接访问类的私有成员，
	从而避免不经意间改变了类的内部状态。

下面演示了private关键字的使用：

public class Person {
    
    
   private String name;
   private int age;
   
   public Person(String name, int age) {
    
    
       this.name = name;
       this.age = age;
   }
   
   public void sayHello() {
    
    
       System.out.println("Hello, my name is " + name);
   }
   
   private void increaseAge() {
    
    
       age++;
   }
   
   public void celebrateBirthday() {
    
    
       increaseAge();
       System.out.println("Happy birthday! Now I'm " + age + " years old.");
   }
}

在上述代码中，name和age字段被声明为private，只能在Person类的内部访
问。sayHello方法是公有方法，可以被外部代码调用。increaseAge方法被声明
为private，只能在Person类的内部调用。
这意味着，当我们创建一个Person对象并调用celebrateBirthday方法时，
age的增加是在类的内部发生的，外部代码无法直接访问和更改age的值。

Person person = new Person("Alice", 25);
person.sayHello();  // 正确，输出：Hello, my name is Alice
person.increaseAge();  // 错误，无法调用私有方法
System.out.println(person.age);  // 错误，无法访问私有字段
person.celebrateBirthday();  // 正确，输出：Happy birthday! Now I'm 26 years old.

In short

private关键字用于限制类的成员的访问范围，只允许在所属类的内部访问。通
过使用private关键字，可以实现封装，提高代码的安全性和可维护性。

this keyword

There are mainly the following uses:

An instance variable that refers to the current object

在类的方法内部，如果局部变量和实例变量同名，可以使用this关键字来指定访
问实例变量。例如：this.variableName。

Call other methods of the current object

在类的某个方法内部，可以使用this关键字来调用当前对象的其他方法。
例如：this.methodName()。

Call other constructors in the constructor

在一个类中，可以定义多个构造方法，通过使用不同的参数列表进行重载。如果
一个构造方法需要调用另一个构造方法，可以使用this关键字。
例如：this(parameters)。

code example

public class crj {
    
    
    public static void main(String[] args) {
    
    
        Student2 s = new Student2();

        s.setName("林清玄");
        s.setAge(30);
        System.out.println(s.getName()+","+s.getAge());
    }
}
public class Student2 {
    
    
    private String name;
    private int age;

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

    public void setAge(int age) {
    
    
        this.age = age;
    }
    public int getAge(){
    
    
        return age;
    }
}

Constructor Notes

    创建 如果没有定义，系统将给出一个默认的无参构造方法
          如果定义了，系统将不再提供默认构造方法
    重载 如果自定义了带参构造方法，还想使用无参构造方法，就必须再写
    		一个无参构造方法
    推荐 永远提供无参构造方法

	构造方法名称必须与类名完全相同，大小写也要匹配。

	构造方法没有返回类型，连 void 关键字也不需要。

	如果没有显式地定义构造方法，Java 会自动为类定义一个默认的无参构
	造方法。

	如果自定义了有参数的构造方法，Java将不会自动创建无参构造方法。这
	就意味着，如果需要创建一个对象，必须显式地提供一个无参构造方法。

	如果类中同时存在无参构造方法和有参构造方法，那么在创建对象时默认
	首选无参构造方法。

	构造方法可以重载，也就是说可以定义多个具有不同参数列表的构造方法，
	以应对不同的对象创建需求。

	在子类中，构造方法的第一行必须是调用父类的构造方法，否则编译器会自
	动添加默认的 super() 方法调用。