Java面向对象三大特性学习总结

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

怀揣着对未来的憧憬，在三月份的时候选择来到华清远见进行Java学习。在大学时是有学习过Java的相关知识的，但是过了比较久的时间之后，大多数知识都已经忘得差不多了，在三月份时对于这门语言的认知还停留在边缘地带，并没有深入到知识的核心，对于许多知识点还停留在表面（也就是只是知道这个概念而已），所以来到华清远见进行学习，一切从零开始，认真学习，慢慢积累，多理解多思考。

在完成面向对象这一阶段的学习之后，让我对Java这门语言有了更深入的理解。

对于Java这门语言来说，万物皆可看为对象。Java语言是完全面向对象的语言，那什么是面向对象呢？在程序当中，使用对象来映射现实世界中的实体，使用对象之间的关系来对实体之间的联系进行描述，这种思想就是面向对象的思想。

什么是对象呢，简单来说，真实世界里一个个体就是一个对象，比如一个人是一个个体，那么他就是一个对象。一头大象是一个个体，它也是一个对象，一台冰箱是一个个体，这台冰箱也是一个对象。把对象进行抽象描述，就是类。类是Java语言最基本单位。对象是由类创建出来的。类是对象的集合，它由属性和方法组成。

package com.hqyj.oop.classes;

/**
 * 学生类
 */
public class Student {

    //属性  属性必须写在类里
    String name;
    int age;
    char sex;
    long number;

    //打印学生信息的方法
    public void studentInfo(){

        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("性别：" + sex);
        System.out.println("学号：" + number);
    }
}

创建的student对象，必须具有属性（成员变量）：姓名name，年龄age，性别sex等，和行为（成员方法）：工作、学习等。

创建好类之后使用new关键字来使用类。

面向对象的三大特性：封装、继承、多态。

一、封装

概述：将对象的属性和实现细节隐藏起来，不让外部程序直接进行访问，将属性私有化，仅对外公开接口，让外部程序通过类提供的方法来对隐藏信息进行访问和操作。好处是外部程序只能通过类规定的方法对数据进行访问，避免外界程序对类内部属性进行破坏。

如何进行封装：属性使用private修饰，提供公共的set和get方法。

/**
 * 实体类Person:私有化属性、提供setter&&getter、无参构造、有参构造、
 *
 * 面向对象的三大特征：封装，继承，多态 --（抽象）
 * 封装：私有化属性，提供公共的set和get方法
 */
public class Person {

    private String name;//将属性设置为private
    private int age;

    //提供set和get方法
    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、proteced、default（默认）、private

Private：修饰的成员只能被这个类本身访问。

Default（默认）：可以被这个类本身和同一个包中的类访问。

Protected：可以被这个类本身、它的子类和同一个包中的其他类访问。

Public：可以被任意类访问。

内部类：在一个类里定义了一个类，就叫内部类。

内部类的作用：内部类有更好的封装，内部类的信息隐藏在外部类中，不允许同一个包中的类访问。内部类只服务于外部类，可以获取外部类的所有属性和方法。

this关键字：

封装时经常会用到this关键字，当方法参数名称和属性名称同名时，this关键字能有效解决这个问题。

this.属性  调用当前属性

this.方法  调用当前方法

谁调用了this.属性或方法中的某个属性和方法，则this就指谁。

二、继承

继承可以对代码进行复用以提高编程的效率，继承就是子类获取父类的成员变量及成员方法。已经存在的类称为父类（也叫基类，超类），新构建的类称为子类（派生类）。Java中通过extend关键字声明一个类从另一个类继承而来。

父类：

public class Father {
    String name;
    int age;
    double salary;

    public Father() {
        System.out.println("Father的无参构造方法...");
    }

    public Father(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public void show(){
        System.out.println("Father...show...");
    }
}

子类：

public class Son extends Father{

    public Son() {
        super();
        System.out.println("son的无参构造方法");
    }

    public Son(String name, int age, double salary) {
        //super关键字必须放在构造方法的第一行
        super(name, age, salary);
    }

    public void show(){
        System.out.println("show子类...");
    }

    public void sonShow(){
        System.out.println("sonShow...");
    }

    public static void main(String[] args) {
//        Son son = new Son("zhang3",18,10000)
//        son.show();
//        System.out.println(son.name);
        Father f =  new Son();//父类引用指向子类对象
        f.show();
        Son s = new Son();
//        s.sonShow();
        s.show();
    }
}

注意：

1.父类可以有多个子类，但子类只能继承一个父类（单继承，Java中不支持多继承）。一个子类不能继承多个父类，但可以实现多个接口。

2.子类不能继承父类中private修饰的属性和方法。

3.子类可以重写父类的方法。

方法的重写：

子类中的一个方法拥有与其父类中一个方法的相同的名称，参数，和返回值时，称为子类重写父类的方法。

父类：

子类：

 输出结果：

 重写的方法具有与其所重写的方法相同的名称、参数数量、类型和返回值。

Super关键字：

Java中通过super关键字来实现对父类成员的访问，super用来引用当前子类对象的父类。

1.通过super访问父类中隐藏的成员变量。

2.通过super调用父类中被重写的方法。

3.子类不继承其父类的构造方法，但可以通过super调用父类的构造方法。使用无参数的super时，调用父类无参构造方法。使用带参数的super时，调用父类有参构造方法。

4.调用父类的构造方法时，super关键字必须放在子类构造方法的第一行。

final关键字：

final修饰的成员变量不可改变，被final修饰的方法不能被子类重写，final修饰的类不能被继承。常见的被final修饰的类有String、Math等等。

被final修饰的成员变量进行初始化时有两种方式：

1.声明时初始化：final int age = 18;

2.在构造方法中初始化：

final int age;
public Test {
Age = 18;
};

三、多态

在Java中，多态指调用同一个方法，不同的对象可能会有不同的行为。简单来讲，在生活中，一个人去吃饭，如果这个人是亚洲人，他可能会用筷子吃饭，如果这个人是欧洲人，他可能会用刀叉吃饭。吃饭这一动作，不同的人可能会用不同的方式去完成，这就是多态的体现。

多态实现的三个前提：

1.存在继承关系

2.必须要有方法的重写

3.父类的引用指向子类对象

通过一个例子来感受多态：

创建一个Person类

创建一个Asian类，继承Person类，重写Person类中的方法

创建一个测试类：

运行结果：

使用多态时，将Asian类向上造型成Person类，重写父类方法后，父类引用指向子类对象调用成员方法时，运行的是子类的方法体。（向上造型不能调用子类特有的成员方法）

若想要调用子类特有的成员方法，需要进行强制类型转换

向下造型：（前提：必须写出父类引用指向子类对象作为前提）

格式：子类类型 变量名 = (子类类型) 父类变量名;

向下造型后变量数据类型转换为子类类型，就可以调用子类特有的成员方法。

运行结果：

instanceof是判断某个引用指向的对象是否为指定类型

格式为：对象名 instanceof 类名