开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第6天，点击查看活动详情

前言

本文为将为大家介绍Java基础面向对象编程的相关知识，我们知道Java的三大特征是封装，继承与多态，那么这三个特点究竟是什么意思呢，本文将通过具体的例子为大家介绍Java面向对象编程，帮助大家理解其中的含义，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

一、认识面向对象

编程思想其实可以分为两种：面向过程思想和面向对象的思想，那么究竟什么是面向过程，什么是面向对象呢，下面我们首先来看看两者的含义。

1.面向过程&面向对象

面向过程思想

执行步骤清晰简单，第一步做什么，第二步做什么….
面对过程的思想适合用于处理一些较为简单的问题

事实上我们写的大多数代码都离不开面向过程，我们写的许多代码片其实都是面向过程进行执行的，虽然有些地方用到了面向对象的思想。

面向对象思想

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象的思想适合用于处理复杂的问题，尤其适合处理需要多人协作的问题!

需要注意的是，我们在编写代码时，对于描述比较复杂的事物，为了能够从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到一些微观的操作,仍然需要面向过程的思路去处理。因此，面向过程与面向对象两种编程思想不是非此即彼的，两者是互相穿插，优势互补的。

2.什么是面向对象编程

上边我们既了解了面向过程的思想，也了解了面向对象的思想，那么面向对象编程是什么意思呢，对于初学Java的小伙伴来说可能还不是很理解。

面向对象编程，Object-Oriented Programming, 简写：OOP
面向对象编程的本质就是:以类的方式组织代码，以对象的形式封装数据
面向对象编程需要抽象的编程思想，把所有事务都抽象成一个类
面向对象编程的三大特性：封装，继承，多态
如果从认识论角度考虑是先有对象后有类。对象指的是具体的事物。而类是对对象的抽象，是抽象的
但是如果从代码编写与运行的角度去考虑是先有类后有对象。类是对象的模板，需要先定义好类才能有对象

二、对象的创建与分析

通过上边的介绍，相信大家对于类与对象有了一定的认识，接下来介绍一下对象的创建，首先来看看类与对象之间有着什么样的关系。

1.类与对象的关系

类是一种抽象的数据类型,它是对某一类事物的整体描述/定义,但是并不能代表某一个具体的事物.

比如我们周围的动物、植物、电脑、衣服，这些都是某一类事物，而不是具体的一个….
在ava代码中我们可以定义一些类，比如Person类、Cat类、 Car类等, 这些类都是用来描述/定义某一类具体的事物（人，猫，车等）以及它们应该具备的特点和行为，但并不能代表一个具体的事物，比如这个Person不能代表有一个具体的人

对象是抽象概念的具体实例

比如王五是人的一个具体实例,王五家里的旺旺是狗的一个具体实例
能够体现出具体的特点,展现出具体的功能的是具体的实例,而不是一个抽象的概念.

我们在用Java代码编程就可以用这种思想，要想用到某一个具体的对象，先定义好相关的类，然后在需要使用的时候再去创建相应类的对象。

2.对象创建与初始化

上边为大家介绍了类与对象的关系，下边就来看看对象该如何创建吧。

当已经定义好某一个类后，可以使用new关键字去创建相对应的对象
我们在使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:1.必须和类的名字相同；2.必须没有返回类型,也不能写void

下面我们通过一个代码示例为大家展示类的定义以及对象的创建。

代码示例：

//学生类
public class Student {
    //属性:字段
    String name;//没有赋值，默认为null
    int age;//没有赋值，默认为0
    int grade; // 年级
    //方法
    public void study(){
        System.out.println(this.name+"正在学习");
    }
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //类:抽象的，要实例化
        //类实例化后会返回一个自己的对象!
        //student对象就是一个Student类的具体实例!
        Student student = new Student();
        student.name = "李四";
        student.grade = 6;
        student.age = 12;
        System.out.println("姓名:"+student.name);
        System.out.println("年级:"+student.grade);
        System.out.println("年龄:"+student.age);
    }
}

// 输出
姓名:李四
年级:6
年龄:12

3.构造器

在面向对象编程中，构造器也是非常重要的，下边就来看看什么是构造器。

构造器：是和类名相同的；构造器没有返回值
作用：在创建对象使用new的时候，本质上是在调用构造方法；作用是初始化对象的值
注意点：定义了有参构造器之后，如果想使用无参构造，需要显示的定义一个无参的构造器，如果没有定义构造器，是默认只有一个无参的构造器

下边我们通过代码示例来看看对于构造器是如何定义以及如何使用的。

代码示例：

public class Person {
    //一个类即使什么都不写，它也会存在一个方法就是构造器
    //显示的定义无参构造器
    String name;
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Person(){
//        this.name = "张三";
    }
    //有参构造:一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //new实例化了一一个对象
        Person person = new Person("张三");
        System.out.println(person.name);
    }
}

// 输出
张三

三、面向对象三大特征

想必大家听说过面向对象的三大特征：封装，继承与多态。但是这三个特征代表什么含义呢？接下来我们逐一详细为大家介绍这三大特征。

1.封装

我们程序设计要追求“高内聚，低耦合”。高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装(数据的隐藏)：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。记住这句话就够了:属性是私有的，要想获取或者设置需要通过get/set方法
封装的优点：1.提高程序的安全性，保护数据；2.隐藏代码的实现细节；3.统一接口；4.系统可维护增加了

下边我们通过一个代码来看看是如何进行封装的。代码示例：

// Student类

public class Student {
    //属性私有
    private String name;//名字
    private int age;//年龄
    private int idCard;//学号
    private char sex;//性别
    //提供一些可以操作这个属性的方法!
    //提供一些public 的get、set方法
    //get获得这个数据
    public String getName() {
        return name;
    }
    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age>120||age<0){ //不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
    public int getIdCard() {
        return idCard;
    }
    public void setIdCard(int idCard) {
        this.idCard = idCard;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
   // 还可以定义一些方法，比如吃饭，睡觉，学习等
}

// Application类
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("李四");
        System.out.println(s1.getName());
        s1.setAge(19);
        System.out.println(s1.getAge());
    }
}

2.继承

面向对象的第二大特征是继承，继承是类和类之间的一种关系。

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
具有继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示
子类和父类之间,从意义上讲应该具有”is a”的关系，比如猫是一种动物，所以猫这一个类就继承了动物这个类

super注意点:

我们在使用super关键字时要注意以下几点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法

super与this比较:

super与this两个关键字的区别：

代表的对象不同：this:本身调用者这个对象；super:代表父类对象的应用
前提：this:没哟继承也可以使用；super:只能在继承条件才可以使用
构造方法：this() 是本类的构造；super()是父类的构造

重写

继承中还有重写这一概念：

重写:需要有继承关系，子类重写父类的方法
重写都是方法的重写，和属性无关
重写时的方法名必须相同
重写的方法的参数列表也必须相同
重写的方法得修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
重写抛出的异常的范围，可以被缩小，但不能扩大;ClassNotFoundException —>Exception(大)
重写时，子类的方法和父类必须要一致;方法体不同

那么大家有没有思考过为什么需要重写呢？这是因为父类的功能，子类不一定需要，或者不一定满足，需要重新来定义这一方法。

下面来通过一个代码示例来看看重写时是怎么实现的。代码示例：

// 父类（Father）
//重写都是方法的重写，和属性无关
public class Father {
    public  void test(){
        System.out.println("Father==>test()");
    }
}

// 子类（Son）
public class Son extends Father{
    //Override重写
    @Override //注解:有功能的注释!
    public  void test(){
        System.out.println("Son==>test()");
    }
}

// Application
public class Application {
    public static void main(String[] args) {
        //静态的方法和非静态的方法区别很大!
        //方法的调用只和左边，定义的数据类型有关
        Son son = new Son();
        son.test();
        //父类的引用指向了子类
        Father father = new Father();
        father.test();
        /*
        输出结果:
            Son==>test()
            Father==>test()
        */
    }
}

我们要注意的是；父类中有一些方法区是不能够被重写的。

父类中不能被重写的方法有：

带static修饰的方法（static方法属于类，不属于实例）
带final修饰的方法（final常量修饰符）
带private修饰的类，私有类不能重写

3.多态

下边来看看面向对象的最后一个特点——多态。

多态即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件：有继承关系；子类重写父类方法；父类引用指向子类对象
注意:多态是方法的多态，属性是没有多态性的

下边通过一个具体的代码来理解一下多态的概念。代码示例：

// Person类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

// Student类
public class Student extends Person{
    @Override
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

// Application类
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类
        //Student能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法(只能将父类强制转换成子类对象才能调用)
        //父类引用指向子类对象，
        //在父类new子类，调用时是调用父类，要是子类重写了父类，则调用子类方法
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
        s2.run();//子类重写了父类的方法，执行子类的方法
        ((Student) s2).eat();
        s1.run();
    }
}

从上边可以看出一个普通的人和一个学生（也是人）都有run()这一方法，但是这一方法的具体实现是不一样的，这就体现了方法的多态性。

多态注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常——ClassCastException
存在条件: 继承关系，方法需要重写，父类引用指向子类对象

四、抽象类与接口

1.抽象类

以下是对抽象类相关的概念和特点介绍：

abstract修饰符可以用来修饰方法也可以修饰类：如果修饰方法,那么该方法就是抽象方法；如果修饰类,那么该类就是抽象类。
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
抽象类中存在无参构造方法。

要注意的是，抽象类无法直接进行实例化操作，当一个类实例化之后，就意味着这个对象可以调用类中的属性或者方法了，但在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。

抽象类和接口这两个概念有很多值得我们学习的地方，为了深入理解和思考，我们下边用一个代码例子给大家看看java中怎么定义抽象类和接口。

代码示例：

public abstract class Animal {
    
    // 但是我们不能直接new
    public Animal(){
        System.out.println("animal has created!");
    }
    
    abstract void eat();

    public void print(){
        System.out.println("I'm an Animal!");
    }

}

public class Cat extends Animal {
    public Cat(){
        System.out.println("cat has created!");
    }

    @Override
    void eat() {
        System.out.println("cat is eating!");
    }

    public static void main(String[] args) {
        new Cat();
    }
}

结果：
animal has created!
cat has created!

这个过程说明了，创建子类时，父类依然会被创建，抽象类只有在构建子类的时候才会被构建出实例。

总结：

抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）

2.接口

其实接口是比抽象类更高级的抽象，当然抽象类也是比类更高级的抽象。接口中只能有方法的定义，而不能有实现。

普通类: 只有具体实现
抽象类: 具体实现和规范(抽象方法)都有!
接口: 只有规范! 自己无法写方法。这就体现了约束和实现分离: 面向接口编程。
接口就是规范，定义的是一组规则，体现了现实世界中“如果你…则必须能..的思想。如果你是汽车，则必须能跑。如果你是学生，则必须学习。
接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。
注意：声明类的关键字是class，声明接口的关键字是interface

下面通过具体的代码来理解一下吧

// 接口UserService
//interface 定义的关键字  接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的public abstract
    //返回值类型+参数名+(参数有就写，没有就不写)
    /*
    void shout();
    void run(String name);
    */
    //常量~ public static final
    int AGE = 99;
    //接口中的所有定义的方法其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

// 接口TimeService
public interface TimeService {
    void timer();
}

// 普通类UserServiceImpl实现（也叫继承）UserService,TimeService
//抽象类   extends 只能单继承
//类可以实现接口   implements 接口名  （implement可以多实现，也叫多继承）
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

接口中能定义抽象方法，不能有实例字段、不能有方法实现（静态的可以），java8以后在接口中可以定义默认方法，这个我们先放一放以后再讲。编写接口的目的在于对类的某些能力进行约定和规范，接口不能被实例化，没有构造器。

接口中的方法默认是public的，我们也推荐使用默认的，也就是我们定义接口时，不用写它的权限修饰符。但是因为接口是契约、是约定子类必须具备的某些能力，是需要子类去实现的，所以我们在写借口时，推荐使用javadoc的方式给接口加注释。

接口是多实现的，一个类可以实现多个接口，但是只能继承一个类。接口之间也可以相互继承

后记

以上呢就是为大家分享的Java基础面向对象编程的相关知识，首先了解了面向过程与面向对象的概念，然后通过一些具体的例子对面向对象的三大特点——封装、继承与多态进行了深入的了解，然后最后又为大家介绍了抽象类与接口的相关概念与实现，希望本文的分享对大家有所帮助~如果你想继续深入学习Java相关的知识与技术，请参考：

Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

看完不关注就想跑.gif

Java面向对象编程，封装，继承与多态

前言

一、认识面向对象

1.面向过程&面向对象

2.什么是面向对象编程

二、对象的创建与分析

1.类与对象的关系

2.对象创建与初始化

3.构造器

三、面向对象三大特征

1.封装

2.继承

3.多态

四、抽象类与接口

1.抽象类

2.接口

后记