手捏Java知识点

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

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

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

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

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

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

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修饰的成员只在本类中才能访问
    使用方法
        提供get变量名()用于获取成员变量的值，方法用public修饰
           set变量名(参数)用于设置成员变量的值方法用public修饰


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

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

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.

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

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

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

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

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;
    }
}

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

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

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

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

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

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

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

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