1. 面向对象概述
1.1 对象
对象是类的一个实例，可以有属性和方法。属性是对象的特征，方法是对象的行为。
1.2 类
类是对象的抽象，描述了具有共同属性和行为的一组对象。
1.3 封装
封装是将属性和方法封装在类中，不允许外部直接访问和修改对象的属性，只能通过类的方法进行操作。封装可以提高代码的安全性和可维护性。
示例代码：
public class Person { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
1.4 继承
继承是一种机制，可以让一个类继承另一个类的属性和方法。子类可以继承父类的所有非私有成员(属性和方法)。通过继承，可以实现代码的复用和层次化设计。
示例代码：
public class Student extends Person { private int grade; public int getGrade() { return grade; } public void setGrade(int grade) { this.grade = grade; } }
1.5 多态
多态是一种特性，在面向对象编程中，它允许能够处理不同类型对象的代码在不同类型对象上执行不同的操作。多态使得代码更加灵活和可扩展。
示例代码：
public class Animal { public void sound() { System.out.println("Animal makes sound"); } } public class Cat extends Animal { public void sound() { System.out.println("Cat meows"); } } public class Dog extends Animal { public void sound() { System.out.println("Dog barks"); } } public class Main { public static void main(String[] args) { Animal animal1 = new Cat(); Animal animal2 = new Dog(); animal1.sound(); // Output: Cat meows animal2.sound(); // Output: Dog barks } }
2. 类
2.1 成员变量
成员变量是定义在类中的变量，可以被类的所有方法访问。它们存储对象的状态信息。
示例代码：
public class Student { String name; // 成员变量 public void setName(String name) { this.name = name; } public void display() { System.out.println("Name: " + name); } } public class Main { public static void main(String[] args) { Student student = new Student(); student.setName("John"); student.display(); // Output: Name: John } }
2.2 成员方法
成员方法是定义在类中的方法，可以通过对象调用。它们对对象的操作和行为进行定义和实现。
示例代码：
public class Circle { double radius; // 成员变量 public void setRadius(double radius) { this.radius = radius; } public double getArea() { return 3.14 * radius * radius; } } public class Main { public static void main(String[] args) { Circle circle = new Circle(); circle.setRadius(5.0); double area = circle.getArea(); System.out.println("Area: " + area); // Output: Area: 78.5 } }
2.3 权限修饰符
权限修饰符用于控制类、变量和方法的访问权限。Java提供了四种权限修饰符：private、default、protected和public。
示例代码：
public class Person { private String name; // 只能在本类中访问 String gender; // 只能在本包中访问 protected int age; // 只能在本包和子类中访问 public void setName(String name) { this.name = name; } public String getName() { return name; } }
2.4 局部变量
局部变量是在方法、构造方法或代码块中定义的变量，只在其所在的范围内有效。局部变量必须在使用前初始化。
示例代码：
public class Calculator { public int add(int num1, int num2) { int sum = num1 + num2; // 局部变量 return sum; } public static void main(String[] args) { Calculator calculator = new Calculator(); int result = calculator.add(5, 3); System.out.println("Sum: " + result); // Output: Sum: 8 } }
2.5 局部变量的有效范围
局部变量的有效范围是从其声明的位置开始，到其所在的代码块结束。超出该范围后，局部变量将不再可见。
示例代码：
public class Rectangle { public void calculateArea() { int length = 10; // 局部变量 int width = 5; // 局部变量 int area = length * width; System.out.println("Area: " + area); // Output: Area: 50 } }
2.6 this关键字
this关键字用于引用当前对象，可以在类的成员方法中使用。它可以解决变量名冲突和区分实例变量和局部变量的问题。
示例代码：
public class Car { private String color; // 成员变量 public void setColor(String color) { this.color = color; // 使用this关键字引用成员变量 } public void displayColor() { String color = "Blue"; // 局部变量 System.out.println("Local color: " + color); // Output: Local color: Blue System.out.println("Instance color: " + this.color); // Output: Instance color: Red } } public class Main { public static void main(String[] args) { Car car = new Car(); car.setColor("Red"); car.displayColor(); } }
3 类的构造方法
构造方法是一种特殊的方法，用于创建对象时进行对象的初始化操作。构造方法的名称必须与类名相同，并且没有返回类型。
示例代码：
public class Person { private String name; private int age; // 构造方法 public Person(String name, int age) { this.name = name; this.age = age; } // getter和setter方法 // ... } public class Main { public static void main(String[] args) { Person person = new Person("Alice", 25); } }
上述代码创建了一个名为Person的类，并定义了一个带有两个参数的构造方法。在main方法中，通过调用构造方法创建了一个名为person的Person对象。
4 静态变量和静态方法
静态变量是属于类的变量，所有对象共享同一个静态变量的值。静态方法是属于类的方法，可以直接通过类名调用，无需创建对象。
示例代码：
public class Person { private String name; private static int count; // 静态变量 public Person(String name) { this.name = name; count++; } public static void printCount() { // 静态方法 System.out.println("Count: " + count); } } public class Main { public static void main(String[] args) { Person person1 = new Person("Alice"); Person person2 = new Person("Bob"); Person.printCount(); // 直接通过类名调用静态方法 } }
上述代码中，定义了一个名为Person的类，并包含一个静态变量count和一个静态方法printCount。在构造方法中，每次创建对象时，count的值都会增加。在main方法中，创建了两个Person对象，并通过Person.printCount()直接调用静态方法。
输出结果：
Count: 2
5. 类的主方法
主方法(即main方法)是Java程序的入口点，程序从这里开始执行。主方法必须是public、static和void类型，并且接受一个String数组作为参数。
示例代码：
public class Main { public static void main(String[] args) { System.out.println("Hello, World!"); } }
上述代码中，定义了一个名为Main的类，并包含一个名为main的主方法。在主方法中，调用System.out.println打印"Hello, World!"。
输出结果：
Hello, World!
6. 对象
6.1 对象的创建
在Java中，使用new关键字可以创建一个对象。创建对象时需要调用类的构造方法来初始化对象的属性和执行其他操作。
示例代码：
public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } } public class Main { public static void main(String[] args) { Person person = new Person("Alice", 25); } }
上述代码创建了一个名为person的Person对象，传入了"name"和"age"参数来初始化对象的属性。
6.2 访问对象的属性和行为
通过对象的引用，可以访问对象的属性和调用对象的方法。
示例代码：
public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public void printInfo() { System.out.println("Name: " + name); System.out.println("Age: " + age); } } public class Main { public static void main(String[] args) { Person person = new Person("Alice", 25); person.printInfo(); } }
上述代码创建了一个名为person的Person对象，并调用了对象的printInfo()方法输出对象的信息。
输出结果：
Name: Alice Age: 25
6.3 对象的引用
在Java中，创建对象时会在堆内存中分配空间，并返回一个对象的引用。通过引用可以操作对象，包括访问对象的属性和调用对象的方法。
示例代码：
public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } public class Main { public static void main(String[] args) { Person person1 = new Person("Alice", 25); Person person2 = person1; person2.setName("Bob"); System.out.println(person1.getName()); // Output: Bob } }
上述代码中，创建了一个名为person1的Person对象，并将该对象的引用赋值给person2。然后通过person2对象的引用，修改了person1对象的name属性，并输出了person1对象的name属性值。
输出结果：
Bob
6.4 对象的销毁
在Java中，对象的销毁是由垃圾回收器负责的。一般情况下，当对象没有被引用时，即没有任何引用指向该对象，垃圾回收器会自动将该对象回收。
示例代码：
public class Person { // ... public void finalize() { System.out.println("Object is being destroyed"); } } public class Main { public static void main(String[] args) { Person person = new Person(); person = null; // 解除对象引用 System.gc(); // 请求垃圾回收器执行 } }
上述代码中，在main方法中创建了一个Person对象，并将person变量的引用设置为null。然后通过System.gc()请求垃圾回收器执行，当垃圾回收器执行时，会调用Person类的finalize()方法输出"Object is being destroyed"。
输出结果：
Object is being destroyed
