java入门

面向对象

对象：世间万物皆对象，所谓对象，并不是一个抽象的概念，泛指我们生活中的各式各样的事物都称之为对象。

类和对象的关系

类是抽象的概念，是对象的模板

对象是具体的事物，是类的具体实例

面向对象的编程

面向对象编程是利用编程方式体现出现实中类与对象

从已有现实的类中定义程序中的类（Class)

从类（Class）创建（实例化）具体的对象（Object)

Java创建类的语法

语法：

public class Dog{

  //类的内容

}

类名要有直白意义，最好是英文

首字母大写；类名比较长，每一个单词的首字母要大写

不要数字开头，不要包含特殊字符

创建类的实例对象

类名  对象名  =  new类名（）；

 new关键字是创建实例对象最重要的标志

对象的命名规则

1.对象名要有直白意义，最好是英文

2.首字母小写

3.不要数字开头，不要包含特殊字符

封装

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

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

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

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

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

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

1. class BankAccount {

2. private double balance;

4. double getBalance() {

5. return balance;

6. }

8. void setBalance(double balance) {

9. this.balance = balance;

10. }

11. }

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

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

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

1. public class Person {

2. private String name;

3. private int age;

5. // 定义构造函数

6. public Person(String name, int age) {

7. this.name = name;

8. this.age = age;

9. }

11. // getter方法

12. public String getName() {

13. return name;

14. }

16. // setter方法

17. public void setName(String name) {

18. this.name = name;

19. }

21. // getter方法

22. public int getAge() {

23. return age;

24. }

26. // setter方法

27. public void setAge(int age) {

28. this.age = age;

29. }

30. }

例如：

1. public class Main {

2. public static void main(String[] args) {

3. Person person = new Person("Tom", 20);

4. System.out.println(person.getName()); // 输出Tom

5. System.out.println(person.getAge()); // 输出20

6. person.setAge(18); // 修改年龄为18

7. System.out.println(person); // 输出Person{name='Tom', age=18}

8. }

9. }

继承

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

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

1. class Animal {

2. String name;

4. void eat() {

5. System.out.println(name + " is eating.");

6. }

7. }

9. class Dog extends Animal {

10. void bark() {

11. System.out.println("Woof!");

12. }

13. }

多态

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

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

1. class Shape {

2. void draw() {

3. System.out.println("Draw a shape.");

4. }

5. }

7. class Circle extends Shape {

8. @Override

9. void draw() {

10. System.out.println("Draw a circle.");

11. }

12. }

14. class Rectangle extends Shape {

15. @Override

16. void draw() {

17. System.out.println("Draw a rectangle.");

18. }

19. }

总结

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

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