今天开始面向对象了
面向对象基础
类：由属性和行为组成
属性：在类中通过成员变量来体现
行为：在类中通过成员方法来体现
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关键字
是一个权限修饰符
可以修饰成员
作用：保护成员不被别的类使用，
被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.
总之
private关键字用于限制类的成员的访问范围，只允许在所属类的内部访问。通
过使用private关键字，可以实现封装，提高代码的安全性和可维护性。
this关键字
主要有以下几个用途：
引用当前对象的实例变量
在类的方法内部，如果局部变量和实例变量同名，可以使用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() 方法调用。
