一，JAVA面向对象编程基本概念：
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来表示现实世界中的事物，通过封装、继承和多态等特性来实现代码的复用和模块化。
二，主要包括：
1，类（Class）：用于定义对象的结构和行为的模板。类是对象的抽象表示，包含了数据成员（属性）和成员函数（方法）。以下是一个简单的Java类示例，展示了如何定义一个名为Person的类，并包含一些基本的属性和方法：
```public class Person {
// 成员变量（属性）
private Stringname;
private int age;
// 构造函数
public Person(String name,int age) {
this.name = name;
this.age = age;
}
// 成员方法
public void introduce() {
System.out.println("My name is " +name +" and I am " +age +" years old.");
}
// Getter和Setter方法
public StringgetName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age >=0) {
this.age = age;
}else {
System.out.println("Age cannot be negative.");
}
}
}```
这个Person类包含了两个私有成员变量name和age，分别表示人的名字和年龄。它还有一个构造函数，用于初始化这些成员变量。此外，它还提供了一些公共方法，如introduce()用于自我介绍，以及getName(), setName(), getAge(), setAge()用于获取和设置名字和年龄。
2，对象（Object）：类的实例，具有类定义的属性和方法。对象是具体的实体，可以通过创建对象来使用类的功能。在Java中，可以通过以下步骤来创建一个对象：
(1)声明一个类的对象变量：首先，你需要声明一个类的对象变量，这个变量将用于引用新创建的对象。例如，如果你有一个名为Person的类，你可以声明一个Person类型的变量，如下所示：
```
publicclassPerson{privateString name;privateintage;publicStringgetName(){returnname; }publicvoidsetName(String name){this.name = name; }}
作者：Bo的早八日记
链接：https://www.jianshu.com/p/fee00934f84d
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
```
(2)创建对象：使用关键字new和类的构造函数来创建一个新的对象。例如，要创建一个Person对象，可以这样做：
```
person =new Person();
```
(3)访问对象的属性和方法：一旦你创建了一个对象，你就可以使用点运算符（.）来访问该对象的属性和方法。例如，假设Person类有一个名为name的属性和一个名为sayHello的方法，你可以这样访问它们：
```
person.name ="Alice";// 设置属性值
person.sayHello();// 调用方法
```
下面是一个简单的示例代码，展示了如何创建一个Person对象并访问其属性和方法：
```
public class Person {
Stringname;
public void sayHello() {
System.out.println("Hello, my name is " +name);
}
public static void main(String[] args) {
// 创建Person对象
Person person =new Person();
// 设置属性值
person.name ="Alice";
// 调用方法
person.sayHello();
}
}
```
3，封装（Encapsulation）：将对象的属性和方法包装在一起，隐藏内部实现细节，只暴露必要的接口给外部访问。这样可以保护对象的数据，防止被意外修改。在Java中，可以通过以下方式来实现封装：
（1）使用访问修饰符（Access Modifiers）：Java提供了四种访问修饰符来控制类、属性和方法的可见性。最常用的是private和public。private修饰符表示只有在同一个类中才能访问该成员，而public修饰符表示任何地方都可以访问该成员。
（2）提供公共的getter和setter方法：为了访问私有属性，可以提供公共的getter和setter方法。这些方法允许外部代码获取或设置属性的值，同时可以在这些方法中添加逻辑来验证数据的有效性或执行其他操作。
（3）不直接暴露属性：不要直接将属性设置为public，而是将其设置为private，然后通过公共的getter和setter方法来访问它们。这样可以避免外部代码直接修改属性值，从而保持对象的完整性。
下面是一个示例，展示了如何封装一个名为Person的类：
```
public class Person {
// 私有属性
private Stringname;
private int age;
// 公共构造函数
public Person(String name,int age) {
this.name = name;
this.age = age;
}
// 公共的getter方法
public StringgetName() {
return name;
}
// 公共的setter方法
public void setName(String name) {
this.name = name;
}
// 公共的getter方法
public int getAge() {
return age;
}
// 公共的setter方法
public void setAge(int age) {
if (age >=0) {
this.age = age;
}else {
System.out.println("Age cannot be negative.");
}
}
}
```
在这个例子中，name和age属性被声明为private，这意味着它们只能在Person类内部访问。外部代码不能直接访问这些属性，而是通过公共的getter和setter方法来获取和设置它们的值。这样可以确保对属性的访问受到控制，并且可以在setter方法中添加验证逻辑。
4，继承（Inheritance）：子类可以继承父类的属性和方法，实现代码的复用。子类可以覆盖或扩展父类的方法，以实现新的功能。在Java中，可以通过以下方式来实现继承：
（1）使用extends关键字：要创建一个子类，需要在子类的声明中使用extends关键字后跟父类的类名。例如，如果有一个名为Animal的父类和一个名为Dog的子类，可以这样定义它们：
```
class Animal {
// 父类的属性和方法
}
class Dogextends Animal {
// 子类的属性和方法
}
```
（2）访问父类的属性和方法：子类可以直接访问父类中的公共和受保护的属性和方法。私有属性和方法不能被子类直接访问，但可以通过父类的公共方法进行间接访问。
（3）重写父类的方法：子类可以重写父类的方法，即在子类中重新定义与父类同名的方法。当调用子类对象的该方法时，将执行子类中的方法实现，而不是父类中的方法。
（4）使用super关键字调用父类的方法：子类可以使用super关键字来调用父类的方法。这在子类需要扩展父类的功能而不是完全替换父类方法时非常有用。
下面是一个示例代码，展示了如何在Java中实现继承：
```
public class Main {
public static void main(String[] args) {
// 创建Dog对象
Dog myDog =new Dog();
myDog.name ="Buddy";
myDog.breed ="Golden Retriever";
// 调用继承自Animal类的eat方法
myDog.eat();// 输出：The dog is eating.
// 调用Dog类特有的bark方法
myDog.bark();// 输出：The dog is barking.
}
}
```
在这个例子中，Dog类继承了Animal类，并重写了eat方法以提供特定的行为。同时，Dog类还添加了一个新的方法bark，用于表示狗叫的行为。通过继承，我们可以利用已有的代码，并在需要的地方进行扩展或修改。
5，多态（Polymorphism）：允许不同类的对象对同一消息作出响应。一个父类引用可以指向其子类的对象，调用相同的方法会根据实际对象的类型执行相应的方法。在Java中，多态主要通过以下方式实现：
（1）继承：子类继承父类的属性和方法，并可以覆盖或扩展它们。
（2）接口：类可以实现一个或多个接口，从而提供接口定义的方法的具体实现。
（3）方法重载（Overloading）：在同一个类中，可以定义多个同名但参数不同的方法。
（4）抽象类和抽象方法：抽象类不能被实例化，只能被继承；抽象方法是没有具体实现的方法，需要在子类中实现。
以下是一个简单的Java面向对象编程示例：
```
// 定义一个动物类
public class Animal {
private Stringname;
public Animal(String name) {
this.name = name;
}
public void makeSound() {
System.out.println("动物发出声音");
}
}
// 定义一个狗类，继承自动物类
public class Dogextends Animal {
public Dog(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println("汪汪汪");
}
}
// 定义一个猫类，继承自动物类
public class Catextends Animal {
public Cat(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println("喵喵喵");
}
}
// 主程序
public class Main {
public static void main(String[] args) {
Animal myAnimal =new Animal("动物");
Dog myDog =new Dog("小狗");
Cat myCat =new Cat("小猫");
myAnimal.makeSound();// 输出：动物发出声音
myDog.makeSound();// 输出：汪汪汪
myCat.makeSound();// 输出：喵喵喵
}
}
```
