Java OOP的理解

一、OOP的概念

OOP(Object Oriented Programming)：面向对象编程

二、类与对象

类(class)和对象(object)是OOP的两大核心概念

1.类

类(class)定义了一件事物的抽象特点，也就是定义了事物的属性和行为。比如 “人” 这个类就会包含一切人的特征与行为，姓名、年龄、性别等特征与说话、走路等行为。

Tips：类是对某一事物的描述，是抽象的，概念上的定义。类是一个模板，它描述了一类对象的行为和属性。

(1)定义一个类

格式：

class 类名{
		...
}

Example：

//定义一个类，类名：Person，代表 “人”
class Person{
		...
}

(2)定义类的成员（属性(变量)与行为(方法)）

每个事物都有自己的属性和行为，我们把它们抽象出来定义到类里面，其中属性是个值，定义为变量(成员变量)，行为是个动作，定义为方法。

(a)定义类的成员变量(属性)

例如我们把 “人” 这个事物的属性抽象的提取出来，他们都有 “名字”、“性别”、“年龄”，但是重点是没有具体指是哪个人，所以定义的变量都是没有值。

Example：

class Person{
	String name;//姓名
	String sex;//性别
	int age;//年龄
}

(b)定义类的方法(行为)

例如“人” 会 “说话” ,所以把 “说话” 这个行为提出出来

Example：

class Person{
	String name;//姓名
	String sex;//性别
	int age;//年龄
	
	private void speak(String name, String sex, int age){
		System.out.println("我叫" + name + "，我的性别是" + sex + "，我" + age + "岁了。" );
	}
}

1.对象(object)

对象是类的一个实例（并不是找对象的那个对象），有行为和属性。例如一个人就是一个对象，他的属性有：姓名、性别、年龄；行为有：说话、走路等。

Tips：对象是实际存在的该事物的个体，是具体的，现实的。JAVA中有句话：万物皆对象（感觉有点唯物主义色彩）

(1)创建一个对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象分三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。(每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法)

Example:

class Person(){

	pulic Person(){
	//默认构造方法
	}

	public static void main(Stirng[] args){
	//创建一个Person对象
	Person person = new Person();
	}	
}

(2)调用对象的成员变量和方法

Example：

public class PersonTest(){
	public static void main(String[] args){
		Person person = new Person();//创建一个Person对象
		person.name = "小明";//访问这个对象的成员变量name,并给它赋值为"小明"
		person.sex = "男";//访问这个对象的成员变量sex,并给它赋值为"男"
		person.age = 20;//访问这个对象的成员变量age ,并给它赋值为20
		person.speak(person.name, person.sex, person.age);//调用这个对象的方法speak,给它传值为这个对象的成员变量name、sex、age
	}
}

三、封装、继承、多态

1.封装

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，常见的比如 getter、setter方法。
封装遵循了 “开闭原则”，禁止外部直接访问和修改类的信息。
封装的优点：
● 1. 良好的封装能减少耦合。
● 2. 类内部结构可以自由修改。
● 3. 可以对成员变量进行更精确的控制。
● 4. 隐藏信息，实现细节。

Example：
java封装类：

public class Person {

    private String name;
    private String sex;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

访问与修改：

public class PersonTest {

    public static void main(String[] args) {
        Person person = new Person();
        person.setName("小明");
        person.setSex("男");
        person.setAge(20);

        System.out.println("Name : " + person.getName() + " Sex: " + person.getSex() + " Age: " + person.getAge());
    }
}

输出结果为：

2.继承

继承就是类与类之间的一种关系，子类继承父类的方法与变量(非private修饰符修饰)，减少代码冗杂，提高代码复用性。

继承格式：

class 父类 {
}

class 子类 extends 父类 {
}

继承类型：

继承的特征：

● 1. 子类拥有父类非private方法，属性。
● 2. 子类可以拥有自己的方法和属性，即子类可以对父类进行拓展。
● 3. 子类可以用自己的方式实现父类的方法。
● 4. Java的继承是单继承，但是可以多重集成，单继承就是一个子类只能集成一个父类，多重继承就是A继承B，B继承C，所以C就是B的父类，B就是A的父类。
● 5. 提高了类之间的耦合性也就是继承的缺点，耦合度高会造成代码之间的联系紧密，独立性差。

继承关键字

extends与implements两个关键字，当一个类没有继承的这俩关键字的时候，则默认继承Object类（所有的类都是继承自Object）

(1)extends关键字

在java中，类的继承是单一继承，就是一个子类只能拥有一个父类，所以extends关键字只能继承一个类。

Example：

public class Person {

    private String name;
    private int age;

    public void eat(){
        //吃东西方法的具体实现
    }

    public void sleep(){
        //睡觉方法的具体实现
    }
    

    class WoMan extends Person{

    }
}

(2)implements关键字

使用implements关键字可以变相的使Java具有多继承的特性，使用范围为类继承接口，可以同时实现多个接口（接口之间用逗号间隔）。

Example:

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

(3)super和this关键字

super关键字：通过super关键字实现对父类的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。

Example：

public class Person {

    private void eat() {
        System.out.println("父类方法");
    }

    static class Woman extends Person {
        private void eat() {
            System.out.println("子类方法");
        }

        private void test() {
            super.eat();
            this.eat();
        }
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.eat();
        Woman woman = new Woman();
        woman.test();
    }
}

输出结果为：

(4)final关键字

final关键字声明的类可以把类定义成不可被继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。
注：变量也可以被声明为final，被定义成final的变量不能被修改。被声明为final类的方法自动地声明成final，但是变量不是final。

3.多态

多态是同一个行为具有多个不同表现形式活形态的能力。
多态的优点：
● 1. 消除类型之间的耦合关系。
● 2.可替换性。
● 3.可扩充性。
● 4. 接口性。
● 5. 灵活性。
● 6. 简化性。
多态存在的三个必要条件：
● 继承
● 重写
● 父类引用指向子类对象
比如：
Parent p = new Child();
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译报错；如果有，再去调用子类的同名方法。多态的好处：可以使程序有良好的拓展性，并可以对所有类的对象进行通用处理。

Example：

public class Test {

    public static void main(String[] args) {
        show(new Cat());// 以 Cat 对象调用 show 方法
        show(new Dog());// 以 Dog 对象调用 show 方法

        Animal animal = new Cat();//向上转型
        animal.eat();//调用的Cat的eat
        Cat cat = (Cat) animal;//向下转型
        cat.work();//调用的Cat的work

    }

    public static void show(Animal animal) {
        animal.eat();
        //类型判断
        if (animal instanceof Cat) {//猫做的事情
            Cat cat = (Cat) animal;
            cat.work();
        } else if (animal instanceof Dog) {//狗做的事情
            Dog dog = (Dog) animal;
            dog.work();
        }

    }

    abstract class Animal {
        abstract void eat();
    }

    class Cat extends Animal {

        public void eat() {
            System.out.println("吃鱼");
        }

        public void work() {
            System.out.println("抓老鼠");
        }
    }

    class Dog extends Animal {

        public void eat() {
            System.out.println("吃骨头");
        }

        public void work() {
            System.out.println("看家");
        }
    }

}

运行结果：