Java入门第二季

面向对象的基础知识

面向对象是一种编程思想，它将现实世界中的对象映射到程序中的类和对象。
在Java中，面向对象编程主要体现在以下几个方面：

---

1、对象

对象是现实世界中事物的抽象，它具有状态（属性）和行为（方法）。在Java中，使用class关键字定义一个类，使用new关键字实例化一个对象。

例如：
定义一个Person类，表示一个人，有name和age属性，以及说话speak方法。

class Person {  
    String name;  
    int age;  
  
    void speak() {  
        System.out.println("Hello, I'm " + name + ", I'm " + age + " years old.");  
    }  
}
1
2
3
4
5
6
7
8

---

2、类

类是对象的模板，它定义了对象的属性和方法。在Java中，使用class关键字定义一个类，类名通常是大写字母开头的驼峰式命名。

例如：
定义一个Car类，表示一辆车，有品牌brand属性，和行驶run方法。

class Car {  
    String brand;  
  
    void run() {  
        System.out.println("The car is running.");  
    }  
}
1
2
3
4
5
6
7

---

3、封装

封装是指将对象的状态（属性）和方法（属性）封装在对象内部，外界无法直接访问。在Java中，使用访问修饰符（private、default、protected、public）来控制属性和方法的访问权限。

Java的权限修饰符有优先级高低之分。以下是它们的优先级顺序，从最低到最高：

1. private：最低的优先级，用于定义私有成员和方法。
2. default（没有显式使用任何修饰符）：默认访问控制，用于没有显式声明访问修饰符的成员和方法。
3. protected：用于定义受保护的成员和方法，可以被同一个包中的任何其他类和子类访问。
4. public：最高的优先级，用于定义公共成员和方法，可以被任何其他类访问。

在重写或重载方法时，子类的方法不能具有比父类更严格的访问控制。 例如，如果父类的方法是protected，则子类重写该方法时只能使用protected或public，不能使用private或default。

此外，在Java中，private和default修饰符不具有跨包访问性，而protected和public修饰符可以跨包访问。

例如：
定义一个BankAccount类，账户的余额balance属性设为private，只允许get和set方法访问。

class BankAccount {  
    private double balance;  
  
    double getBalance() {  
        return balance;  
    }  
  
    void setBalance(double balance) {  
        this.balance = balance;  
    }  
}
1
2
3
4
5
6
7
8
9
10
11

---

对类中的成员变量进行封装

在Java中，可以通过封装来控制对成员变量的读写访问。以下是对成员变量进行读写封装的步骤：

1. 定义一个类，并定义成员变量。
2. 在类中使用getter方法来读取成员变量的值。
3. 在其他类中使用该类，并通过getter方法获取成员变量的值。如果需要修改成员变量的值，则使用setter方法。

---

定义：

public class Person {  
    private String name;  
    private int age;  
  
    // 定义构造函数  
    public Person(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    // getter方法  
    public String getName() {  
        return name;  
    }  
  
    // setter方法  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    // getter方法  
    public int getAge() {  
        return age;  
    }  
  
    // setter方法  
    public void setAge(int age) {  
        this.age = age;  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

---

使用：

public class Main {  
    public static void main(String[] args) {  
        Person person = new Person("Tom", 20);  
        System.out.println(person.getName());  // 输出Tom  
        System.out.println(person.getAge());  // 输出20  
        person.setAge(18);  // 修改年龄为18  
        System.out.println(person);  // 输出Person{name='Tom', age=18}  
    }  
}
1
2
3
4
5
6
7
8
9

---

4、继承

继承是指子类可以继承父类的属性和方法，并且可以在子类中添加新的属性和方法或者重写父类的方法。在Java中，使用extends关键字实现继承。

例如：
定义一个Animal类作为父类，定义一个Dog类作为子类，Dog类继承了Animal类的属性和方法。

class Animal {  
    String name;  
  
    void eat() {  
        System.out.println(name + " is eating.");  
    }  
}  
  
class Dog extends Animal {  
    void bark() {  
        System.out.println("Woof!");  
    }  
}
1
2
3
4
5
6
7
8
9
10
11
12
13

---

5、多态

多态是指同一个方法在运行时可以根据对象的实际类型来执行不同的代码。在Java中，通过继承和重写实现多态。

例如：
定义一个Shape类作为父类，定义一个Circle类和一个Rectangle类作为子类，它们都重写了Shape类的draw方法。

class Shape {
void draw() {
		System.out.println("Draw a shape.");
	}
}

class Circle extends Shape {
@Override
void draw() {
		System.out.println("Draw a circle.");
	}
}

class Rectangle extends Shape {
@Override
void draw() {
		System.out.println("Draw a rectangle.");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---

总结

Java是一种面向对象的编程语言，它的基础知识包括：

1. 类和对象：类是对象的模板，定义了对象的状态和行为。对象是类的实例，是类的具体实现。
2. 封装：通过访问修饰符将类的属性和方法隐藏起来，外部无法直接访问，提高了代码的安全性和可维护性。
3. 继承：通过extends关键字实现继承，子类继承了父类的属性和方法，并可以添加自己的属性和方法。
4. 多态：通过接口和继承实现了多态，同一个方法在运行时根据对象的实际类型来执行不同的代码。
5. 抽象类和抽象方法：抽象类不能被实例化，用于定义抽象方法，抽象方法没有具体的实现。
6. 接口：接口是一种特殊的类，定义了抽象方法，可以被多个类实现。
7. 关键字：Java中的关键字包括class、extends、implements、new、this、super等。
8. 常用类和接口：Java中有很多常用的类和接口，如String、Integer、Double等，它们提供了许多方法和功能。

---

以上是Java面向对象编程的基础知识，是学习Java必须掌握的内容。

					                             END
1