java面对对象

面对对象

类：一组相关的属性和行为的集合，是一个抽象的概念。

对象：该类事物的具体表现形式，具体存在的个体。

成员变量：事物的属性

成员方法：事物的行为

什么是面对对象？

面向对象和面向过程相比，其实就是处理问题的两种角度，两种方式。

比如洗衣机洗衣服这个过程

面向过程：它会将任务拆分为一个个步骤，如：
1、打开洗衣机
2、把衣服放进去
3、放洗衣粉
4、清洗衣服
5、烘干衣服

面向对象：它会把任务拆分为几个不同的对象，每个对象有自己的属性和功能，如：
人：打开洗衣机，放衣服，放洗衣粉
洗衣机：清洗衣服、烘干衣服

总结：面向过程如果只处理一项任务的话会比较直接高效，但是面向对象的话，可以进行对象的复用，也方便扩展与维护

封装、继承、多态

封装、继承、多态是java的三大特性

封装

封装的意义，在于明确标识了外部成员可以使用的内部的方法与属性

也就是说，封装对象内部的实现外部成员无需了解细节，只需要知道有什么作用并且去调用使用即可

例：类里面name是私有的，而且它的命名有一定的规范，而我们只需要知道如何设置名字和获取名字就行了，不需要知道代码内部的实现细节

public class Person {
	private String name;
	public Person(String name) {
		this.name = "wu_" + name;
	}
	public setName(String name) {
		this.name = "wu_" + name;
	}
	public gettName() {
		return name;
	}
}

继承

继承基类的方法，并作出自己的改变和扩展

子类共性的方法或者属性可以直接父类的，无需再定义，也可以根据自己的特性去定义属于自己的个性化方法和属性等

class Animal {
    public void run() {
        System.out.println("我能跑");
    }
    public void animal() {
        System.out.println("我是动物");
    }
}
class Bird extends Animal{
    @Override
    public void run() {
        System.out.println("我也能跑");
    }
    public void bird() {
        System.out.println("我是鸟类");
    }
}

多态

基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同

多态实现的条件是在继承中，并且有方法的重写以及父类引用指向子类对象，如下：

public class DuoTai1 {
    public static void main(String[] args) {
        System.out.println("========Animal a1 = new Bird()=======");
        Animal a1 = new Bird();
        a1.run();
        a1.animal();
        System.out.println("=======Animal a2 = new Animal()========");
        Animal a2 = new Animal();
        a2.run();
        a2.animal();
        System.out.println("======Bird b1 = new Bird()========");
        Bird b1 = new Bird();
        b1.bird();
        b1.animal();
    }
}

class Animal {
    public void run() {
        System.out.println("我能跑");
    }
    public void animal() {
        System.out.println("我是动物");
    }
}
class Bird extends Animal{
    @Override
    public void run() {
        System.out.println("我也能跑");
    }
    public void bird() {
        System.out.println("我是鸟类");
    }
}

执行结果：

根据不同的引用不同的对象可以执行不同的逻辑代码，如父类引用子类对象（Animal a1 = new Bird()），a1只能调用父类中有的方法，但是如果子类有重写的话，则会执行子类的方法