JAVA面向对象三大特征详解：(封装，继承，多态)

面向对象语言：

大家经常会听到说JAVA这门语言是面向对象的，但面向对象又是什么呢？

提到面向对象就要引入一个叫做面向过程的概念：

举个例子：把大象装进冰箱，需要几步。

面向过程的做法：

人走到冰箱前面，打开到30°的时候灯开了，然后大象先迈左腿，，然后躺进去，然后右腿然后关一半灯关上了，关上冰箱门。

面向对象的做法：

打开冰箱（负责：人走到冰箱前面，打开到30°的时候灯开了）

存储（负责：大象先迈左腿，然后右腿，然后躺进去）

关闭冰箱（然后关一半灯关上了，关上冰箱门。）

综上：

面向过程是：要先把事物分析成不同的步骤，然后根据步骤一步步的编程。

面向对象是：创建负责某个部分的负责人也就是我们所说的“对象”，在给对象赋值上相应的属性，进行方法形式的编程

关于他们的区别请移至主页

那么了解了什么是面向对象现在就进入正题

面向对象有三大特质：封装，继承，多态

1.封装：

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。”被封装的类通常称为抽象数据类型

通俗来说：当对象调用被封装的方法时，只能看到我想让你看到的。

1.1封装的作用：

• 保护我们的代码不会被我们无意间修改破坏
• 使得代码高内聚和低耦合

“高内聚和低耦合”：

高内聚：尽量操作内容都是自己内部完成的，使自己内部的内容联系紧密，一个类负责一个任务

方便后期修改。

低耦合：“仅需暴露少量的方法给外部使用，尽量方便外部使用。就是说简化外部调用，便有调用者使用，便于扩展和协作。

1.2如何封装：

类的封装就是将类的属性私有化，即用private进行修饰。私有属性只能在他类中被访问

如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法。其中包括用于获取属性值的get方法和设置属性值的set方法 。

几种权限修饰符：

private：私有权限，只能在定义的类中访问，在其他类中创建的实例均无法访问
默认：同包可访问权限，在没有声明权限修饰符时为默认权限，允许在同包的其他类访问
protected：受保护权限，允许有继承关系的子类访问
public：公共权限，允许任何类访问

上图：

如何定义变量：

[权限修饰符]  变量类型   变量名

封装步骤：

1. 新建类
2. 属性名封装但是方法用public提供调用功能也就是建立get/set方法

代码演示：

新建一个Gril类封装name,height,weight属性

package com.baidu5;

public class Gril {
    private String name;
    private double height;
    private double weight;
    public Gril(){
   }

    public void setname(String name){
        this.name=name;
    }
    public String getname(){
        return name;
    }

    public void setheight(double height){
        this.height=height;
    }
    public  double getHeight(){
        return height;
    }



    public void setweight(double weight){
        this.weight=weight;
    }
    public  double getweight(){
        return weight;
    }

     public void show(){
        System.out.println("我女朋友叫"+name+"体重为"+weight+"身高为"+height);
     }

}

package com.baidu5;

public class test {
    public static void main(String[] args){
        Gril sx=new Gril();
        sx.setname("jelly");
        sx.setheight(178);
        sx.setweight(120);
        sx.show();
//如果没有属性封装那么属性都可以直接调用：
/*
        sx.name(形参);
*/
    }

}

2.继承：

这是一个非常形象的概念，就像是日常生活中子女继承父辈的遗产。在程序中大致是这样的：

有两个类一个是动物还有一个类是猫，程序中可以描述为猫是继承（extends）自动物这个类的

那么这个动物类就可以称为猫的父类，猫就是动物的子类。

一个父类可以有多个子类但一个子类只能有一个父类就像一个人不能有多个亲爹一样，但一个父可以有多个孩子一样。

2.1继承性的作用：

多个类都有共同的属性，行为时，就可以向上抽取相同的属性行为，就不用在重新定义了。

所以可以说，父类是由子类向上抽取共性而来的。

总结：

1.继承类（子类）获得（父类）被继承类的方法和属性前提是，父类中方法属性非私有

2父类是由子类向上抽取共性而来的。

3.因为子类是继承是父类所以子类的功能要大于父类，不然继承没啥意义。

继承性的格式（extends）：

public class 父类{

}

public class 子类 extends 父类{

}

2.2示例：

创建一个父类animal

package com.继承3;

public class animal {
    private int age ;
    private String name;
    private String color;

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

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

    public void setColor(String color){
        this.color=color;
    }
    public String getcolor(){
        return color;
    }


}

在创建一个子类dog继承自animal，dog的独特功能就是可以狗叫

package com.继承3;

public class dog extends animal{

    public dog(){

    }
    public void getshout(){
        System.out.println("狗叫");
    }

}

定义一个测试类：很明显，对象lxx是dog类的对象但是可以调用animal类中的方法。

package com.继承3;

public class test {
    public static void main(String[] args){
        dog lxx=new dog();
        lxx.getshout();
        lxx.setAge(6);
        lxx.setColor("color");
        System.out.println();




    }


}

3 多态：

多态，故名思意，事物的多种形态。

3.1多态的前提：

• 有继承性关系
• 要有方法的重写
• 必须是父类引用子类的对象

3.2例1

假设现在有一个Person方法：这里面有这么些个方法，

package com.duotai1;

public class Person {
    public Person(){

    }
    public void Eat(){
        System.out.println("人吃饭");
    }
    public void Sleep(){
        System.out.println("人睡觉");
    }
    public void Walk(){
        System.out.println("人走路");
    }
}

然后定义一个Banker银行家家类来继承Perosn类，并且重写Walk方法和添加特有的invest类

package com.duotai1;

public class Banker extends Person {
    public void Sleep(){
        System.out.println("Banker sleep very late very day");

    }
    public void Walk(){
        System.out.println("Banker sit all day long");
    }
    public void invest(){
        System.out.println("Banker invest very well");
    }
}

定义Test类测试：

package com.duotai1;

public class test {
    public static void main(String[] args) {
        
        Person p=new Banker();
        p.Sleep();
        p.Eat();
        p.Walk();
      //p.invest会报错，报错原因是跟多态性的特性有关
     //多态性不能直接的调用子类的特有的对象，只能直接调用父类的对象
     //若没有重写过父类的方法则会直接调用父类的方法


    }
}

 赋上运行该结果：

在现实生活中直接用父类引用子类对象的使用性很低。

  p.invest会报错，报错原因是跟多态性的特性有关
  多态性不能直接的调用子类的特有的对象，只能直接调用父类的对象
  若没有重写过父类的方法则会直接调用父类的方法

要想调用子类方法那么就要用一个关键字判断（instanceof）

instanceof:（详解看主页）

instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。

3.3一般多态的使用情况

使用父类作为方法参数 ，便可以将所有子类传至方法中

代码如下：

父类

package com.duotai1;

public class Person {
    public Person(){

    }
    public void Eat(){
        System.out.println("人吃饭");
    }
    public void Sleep(){
        System.out.println("人睡觉");
    }
    public void Walk(){
        System.out.println("人走路");
    }
}

子类Banker有自己的方法invest

package com.duotai1;

public class Banker extends Person {
  
    public void invest(){
        System.out.println("Banker invest very well");
    }
}

子类Student有方法Study

public class Student extends Person{
    public void study(){
        System.out.println("学生天天学习");
    }

}

定义test类：

package com.duotai1;

public class test {
    public static void main(String[] args) {


        Student sx=new Student();
        Banker sx1=new Banker();
        getsonclass(sx);
        getsonclass(sx1);

    }
    public static void getsonclass(Person Tom){
        if(Tom instanceof Student){
            Student c1=(Student) Tom;
            c1.study();
        } else if (Tom instanceof Banker) {
            Banker c2=(Banker) Tom;
            c2.invest();
        }


    }
}

 其实这就是多态：

Student sx=Student();

Person Tom=sx  //sx就是new Student

Person Tom=new Student();

运行结果：

调用成功子类方法成功