java面向对象之三大特征

Java面向对象编程作为一种编程思想，有三大特性，封装，继承，多态。它将数据和操作数据的方法封装在对象中，从而使对象具有相应的功能，也就是说面向对象是将功能等通过对象来实现，具体的细节由对象完成。通俗而言，这种思想是当遇到一件事时，思考“由谁来完成这件事”，而不是去想这件事该怎么完成。这个“谁”就是对象，我们不需要了解他是如何完成此事，只需要一个结果。

例如：你是一个游戏爱好者，想上分怎奈技术不行，于是你决定找代打帮上分。此时你只需要付钱，让别人帮你冲分，不需要了解他是怎样操作的，最后只要达到你的要求就好了。

一、封装

封装概述

封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，在这个内部里，我们对数据进行隐藏和保密，只留下一些接口供外部调用，外界无法直接调用。

封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法。

示例代码：

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public static void main(String[] args) {
        Person p = new Person();
        p.setName("乔乔");
        p.setAge(21);
        System.out.println("我叫~"+p.getName()+"今年"+p.getAge());
    }
}
//输出结果：
我叫~乔乔今年21

四种权限修饰符

private修饰的属性或方法为该类所特有，在任何其他类中都不能直接访问；default修饰的属性或方法具有包访问特性，同一个包中的其他类可以访问；protected修饰的属性或方法在同一个中的其他类可以访问，同时对于不在同一个包中的子类中也可以访问；public修饰的属性或方法外部类中都可以直接访问。

修饰符	同一个类中	同一个包中子类无关类	不同包的子类	不同包的无关类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

private和this关键字

private是一个权限修饰符，可以修饰成员（成员变量和成员方法）；作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问。

注意：针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作。

1.提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰。

2.提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰。

this关键字代表当前对象

this.属性操作当前对象的属性。
this.方法调用当前对象的方法。

修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

注意：

1.方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量。

2.方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量。

封装好处

通过方法来控制成员变量的操作，提高了代码的安全性；把代码用方法进行封装，提高了代码的复用性。

二、继承

继承概述

继承是类与类的一种关系，可以使得子类有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承，如“狗类”继承“动物”，这里动物类是狗类的父类或者基类、超类，狗类是动物类的子类或者派生类。

继承通过extends实现，public class Dog extends Animal。

注意：java中类只支持单继承，不支持多继承，但可以多层继承。

继承利与弊

好处：1.提高了代码的复用性（多个类相同的成员可以放到同一个类中）2.提高了代码的维护性（如果方法的代码需要修改，修改一处即可）。
弊端：继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性。

this&super的三种用法

关键字

访问成员变量

访问构造方法

访问成员方法

this

this成员变量

访问本类成员变量

this(...)

访问本类构造方法

this.成员方法(...)

访问本类成员方法

super

super成员变量

访问父类成员变量

super(...)

访问父类构造方法

super.成员方法(...)

访问父类成员方法

访问特点

（一）继承中变量的访问特点：在子类方法中访问一个变量，采用的是就近原则。

1.子类局部范围找；2.子类成员范围找；3.父类成员范围找；4.如果都没有就报错。（不考虑父亲的父亲...）

示例代码：

public class Fu {
    int num = 10;
}
public class Zi extends Fu {
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();	// 输出show方法中的局部变量30
    }
}

（二）继承中构造方法的访问特点：子类中所有的构造方法默认都会访问父类中无参的构造方法。

原因：

1.子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。

2.每一个子类构造方法的第一条语句默认都是：super()。

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法

2. 在父类中自己提供一个无参构造方法（推荐）

（三）继承中成员方法的访问特点：通过子类对象访问一个方法。

1.子类成员范围找；2.父类成员范围找；3.如果都没有就报错。（不考虑父亲的父亲...）。

方法重写

概述：子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）。

应用场景：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

注意事项：

1. 私有方法不能被重写（父类私有成员子类是不能继承的）。

2. 子类方法访问权限不能更低（public > 默认 > 私有）。

三、多态

多态概述

什么是多态：同一个对象，在不同时刻表现出来的不同形态（多态就是对象的多种形态）。

多态的前提：1.要有继承实现的关系；2.要有方法的重写；3.要有父类引用指向子类对象。

多态利与弊

好处：提高程序的扩展性、通用性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。
弊端：不能使用子类的特有成员。

成员访问特点

成员变量：编译看父类，执行看父类

成员方法：编译看父类，执行看子类

原因：因为成员方法有重写，而成员变量没有

示例代码：

//动物类
public class Animal {
    public int age = 8;

    public void eat() {
        System.out.println("动物吃东西");
    }
}

//猫类
public class Cat extends Animal {
    public int age = 4;
   
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

        System.out.println(a.age);
        a.eat();
    }
}
//输出结果：
8
猫吃鱼

多态转型

向上转型：从子到父--->父类引用指向子类对象 Animal a = new Cat();

向下转型：从父到子--->父类引用转为子类对象子类型对象名 = (子类型) 父类引用 Cat c = (Cat)a;

补充（instanceof）

instanceof是Java的一个保留关键字，左边是对象，右边是类，返回类型是Boolean类型。它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回true，否则返回false。先有继承关系，再有instanceof的使用。需要用到对象的强制类型转换时，需要用instanceof进行判断。