Java中的面向对象详解（通俗易懂）

谁践踏了优雅 2023-09-26 09:26 231阅读 0赞

#### 文章目录 ####

*  面向对象
 *   *  一、对象的概念
     *  二、面向对象
     *  三、类
     *  四、类的定义
     *  五、对象的创建和使用
     *  六、对象和类的关系
     *  七、实例变量和临时变量
     *  八、实例方法
     *  九、方法的重载（overload）
     *  十、构造方法
     *  十一、this关键字

## 面向对象 ##

### 一、对象的概念 ###

> 在程序界，对象相当于哲学中的物质。
> 
> 一切事物皆为对象，万物皆对象。

> 对象具备有特征和行为。
> 
> 特征：使用名词，代表该对象有什么，也叫属性。例如：大小、颜色等
> 
> 行为：使用动词，代表该对象能做什么，也叫方法。例如：吃、走、跑、叫等

### 二、面向对象 ###

> 面向对象的编程（OOP）（Object Oriented Programming）。
> 
> 面向过程的编程，C语言

> 把大象放冰箱问题。
> 
> 使用面向过程，考虑的是步骤：
> 
> 1、把冰箱门打开
> 
> 2、把大象塞进去
> 
> 3、把冰箱门关上
> 
> 使用面向对象的编程，需要考虑的是涉及到哪几个对象？他们具备哪些属性和方法？对象之间的关系是如何构成的？
> 
> 对象：冰箱、大象、推er（具备有将大象放进冰箱的功能的对象）
> 
> 属性和方法：（与当前业务相关的属性和方法）
> 
> 冰箱：
> 
>  *  属性：大小、门
>  *  方法：开、关
> 
> 大象：
> 
>  *  属性：大小
> 
> 推er：
> 
>  *  方法：（把大象）放进去
> 
> 面向过程的思想一般用来解决相对简单的问题，因为其过程比较简单，适合于简单项目。
> 
> 而面向对象的思想一般会比面向过程要复杂，需要分析各种参与的对象的属性和方法，适合于复杂的项目业务，有良好的可扩展性和可维护性。

### 三、类 ###

> 在具备相同的特征和行为的对象中，抽取出共性的特征和行为，叫做类。

### 四、类的定义 ###

> 定义一个类：
> 
> 由属性和方法组成。属性即一些变量，属性和方法在类中并列存在。
> 
> 注意：方法先不要加static关键字。

public class Dog {
        
    	String breed; // 品种
    	int age; // 年龄
    	String sex; // 性别
    	String furColor; // 毛色
    	public void eat() {
        
    		System.out.println("正在吃...");
    	}
    	public void sleep() {
        
    		System.out.println("正在睡...");
    	}
    }

### 五、对象的创建和使用 ###

public class TestMain {
        
    	public static void main(String[] args) {
        
    		// 创建对象
    		Dog dog = new Dog();
    		// 给属性赋值
    		dog.breed = "哈士奇";
    		dog.age = 1;
    		dog.sex = "公";
    		dog.furColor = "黑白";
    		// 取值
    		System.out.println("狗的品种为：" + dog.breed + "，年龄为：" + dog.age + "，性别为：" + dog.sex
    				+ "，毛色为：" + dog.furColor);
    		// 调用对象的方法
    		dog.eat();
    		dog.sleep();
    	}
    }

### 六、对象和类的关系 ###

> 类是一个相对抽象的概念，是所有的对象的模板，一个类可以创建多个对象。
> 
> 对象是根据模板创建出来的一个具体的实例（instance）。

### 七、实例变量和临时变量 ###

> 在类中定义的普通变量是属性，又称为实例变量。而在方法中定义的变量称为临时变量，又称为局部变量。
> 
> 实例变量的作用域范围是整个类中均可以使用。实例变量即使没有赋值也可以使用，默认值与数组默认值一样。

public class Dog {
        
    	String breed; // 品种
    	int age; // 年龄
    	String sex; // 性别
    	String furColor; // 毛色
    	
    	public void eat() {
        
    		System.out.println("狗的品种为：" + breed + "，年龄为：" + age + "，性别为：" + sex
    				+ "，毛色为：" + furColor + "正在吃...");
    	}
    	
    	public void sleep() {
        
    		System.out.println("狗的品种为：" + breed + "，年龄为：" + age + "，性别为：" + sex
    				+ "，毛色为：" + furColor + "正在睡...");
    	}
    }

public class TestMain2 {
        
    	public static void main(String[] args) {
        
    		// 创建对象
    		Dog dog1 = new Dog();
    		dog1.breed = "哈士奇";
    		dog1.age = 1;
    		dog1.sex = "公";
    		dog1.furColor = "黑白";
    		
    		Dog dog2 = new Dog();
    		dog2.breed = "泰迪";
    		dog2.age = 1;
    		dog2.sex = "公";
    		dog2.furColor = "棕";
    		
    		dog1.eat();
    		dog1.sleep();
    		
    		dog2.eat();
    		dog2.sleep();
    		
    		Dog dog3 = new Dog();
    		dog3.eat();
    		dog3.sleep();
    	}
    }

> 临时变量和实例变量在方法中的使用：

public class Dog {
        
    	String breed; // 品种
    	int age; // 年龄
    	String sex; // 性别
    	String furColor; // 毛色
    	
    	public void eat() {
        
    		int age = 20; // 临时变量，默认使用
    		System.out.println("狗的品种为：" + breed + "，年龄为：" + this.age + "，性别为：" + sex
    				+ "，毛色为：" + furColor + "正在吃..."); // 可以使用this调用属性
    	}
    	
    	public void sleep() {
        
    		System.out.println("狗的品种为：" + breed + "，年龄为：" + age + "，性别为：" + sex
    				+ "，毛色为：" + furColor + "正在睡...");
    	}
    }

> 区别：

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>局部变量</th> 
   <th>实例变量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>定义位置</td> 
   <td>方法内部</td> 
   <td>类的内部，方法外部</td> 
  </tr> 
  <tr> 
   <td>默认值</td> 
   <td>没有，需要先赋值，后使用</td> 
   <td>有，与数组相同</td> 
  </tr> 
  <tr> 
   <td>使用范围</td> 
   <td>在方法内部定义时开始，到大括号结束</td> 
   <td>在类的内部使用</td> 
  </tr> 
  <tr> 
   <td>命名冲突</td> 
   <td>不能相同，会报错</td> 
   <td>可以与局部变量相同，在方法中优先使用局部变量，可以使用this.属性，来访问实例变量</td> 
  </tr> 
 </tbody> 
</table>

### 八、实例方法 ###

> 注意：没有使用static修饰的方法叫做实例方法。需要使用实例（对象）调用。
> 
> 方法由方法声明和方法实现组成。
> 
> 声明即方法的名称，参数列表等。
> 
> 方法的实现即\{大括号中的内容\}。

public void sleep()  // 声明
    // 实现   
    {
        
        System.out.println("狗的品种为：" + breed + "，年龄为：" + age + "，性别为：" + sex
                           + "，毛色为：" + furColor + "正在睡...");
    }

### 九、方法的重载（overload） ###

> 在一个类中，定义了多个相同名称，但是参数列表不同的方法，叫做方法重载。
> 
> 注意：
> 
>  *  参数列表不同包括参数的类型、个数、顺序
>  *  方法重载与返回值类型和访问修饰符无关
> 
> 作用：会自动根据传入的参数找到对应的方法进行调用。对应相同作用的方法，不用去定义不同的名称，避免混淆。例如：系统带的println方法，可以打印多种类型的数据，无需定义不同名称的方法，只需要记住打印方法即可。

public class ClassA {
        
    	public void a() {
        
    		System.out.println("a()");
    	}
    	
    	public void a(int i) {
        
    		System.out.println("a(int i)");
    	}
    	
    	public void a(double i) {
        
    		System.out.println("a(double i)");
    	}
    	
    	public void a(String s, int i) {
        
    		System.out.println("a(String s, int i)");
    	}
    	
    	public void a(int i, String s) {
        
    		System.out.println("a(int i, String s)");
    	}
    }

### 十、构造方法 ###

> 用来创建对象的方法。使用new关键字调用。
> 
> 特点：
> 
>  *  方法名与类名完全相同
>  *  没有返回值类型，注意：没有返回值类型，不是说返回值类型为void
>  *  只能通过new关键字调用
> 
> 注意：如果一个类没有定义构造方法，会自动生成一个默认的无参构造方法。如果手动定义了构造方法，则不会生成默认的无参构造方法。

public class ClassB {
        
    	// 不是构造方法，因为有void返回值类型
    //	public void ClassB() {
        
    //		
    //	}
    	
    	public ClassB() {
        
    		System.out.println("构造方法被调用");
    	}
    }

public class TestClassB {
        
    	public static void main(String[] args) {
        
    		ClassB c = new ClassB();
    	}
    }

> 当一个类有多个属性，而且在创建对象时必须要给所有属性赋值，此时，需要多行代码对属性进行赋值，而且容易遗忘属性。可以使用有参构造方法，简化创建对象的过程，并且对所有属性进行赋值。
> 
> 有参构造方法作用：
> 
>  *  简化属性赋值的过程
>  *  将必要属性设置为参数，调用时必须要赋值，避免遗忘
> 
> 注意：
> 
>  *  当提供了有参构造方法后，无参构造方法无效。
>  *  构造方法可以重载

public class Cat {
        
    	String breed; // 品种
    	int age; // 年龄
    	String sex; // 性别
    	String furColor; // 毛色
    	// 方法重载
    	// 无参构造方法
    	public Cat() {
        
    		
    	}
    	// 有参构造方法
    	public Cat(String b, int a, String s, String f) {
        
    		breed = b;
    		age = a;
    		sex = s;
    		furColor = f;
    	}
    	
    	public void eat() {
        
    		System.out.println("猫的品种为：" + breed + "，年龄为：" + this.age + "，性别为：" + sex
    				+ "，毛色为：" + furColor + "正在吃..."); // 可以使用this调用属性
    	}
    	public void sleep() {
        
    		System.out.println("猫的品种为：" + breed + "，年龄为：" + age + "，性别为：" + sex
    				+ "，毛色为：" + furColor + "正在睡...");
    	}
    }

public class TestCat {
        
    	public static void main(String[] args) {
        
    		Cat cat1 = new Cat(); // 无参构造
    		Cat cat = new Cat("蓝猫", 1, "公", "黑色"); // 有参构造
    		cat.eat(); // 方法调用
    	}
    }

### 十一、this关键字 ###

> 在类中使用表示当前对象。
> 
> 作用：
> 
>  *  调用实例属性
>  *  调用实例方法
>  *  调用其他构造方法

> 调用实例属性，当局部变量的名称与属性名称相同时，用this来调用属性。

public Bird(String breed, int age, String sex, String furColor) {
        
        this.breed = breed;
        this.age = age;
        this.sex = sex;
        this.furColor = furColor;
    }

> 调用实例方法：可以在一个实例方法中使用this调用另一个实例方法，当然，也可以不写this

public void eat() {
        
        System.out.println("鸟的品种为：" + breed + "，年龄为：" + this.age + "，性别为：" + sex
                           + "，毛色为：" + furColor + "正在吃..."); // 可以使用this调用属性
        this.sleep();
    }
    
    public void sleep() {
        
        System.out.println("鸟的品种为：" + breed + "，年龄为：" + age + "，性别为：" + sex
                           + "，毛色为：" + furColor + "正在睡...");
    }

> 调用其他的构造方法：简化构造方法的代码

public Bird(String breed, String furColor, int age) {
        
        this.breed = breed;
        this.furColor = furColor;
        this.age = age;
    }
    
    // 有参构造方法
    public Bird(String breed, int age, String sex, String furColor) {
        
        this(breed, furColor, age); // 调用其他构造方法
        this.sex = sex;
    }