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

 一、封装

封装表现 

 1、方法就是一个最基本封装体。

 2、类其实也是一个封装体。 

从以上两点得出结论，封装的好处：

1、提高了代码的复用性。

2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

3、提高了安全性。

例子：了解到封装在生活的体现之后，又要回到Java中，细说封装的在Java代码中的体现，先从描述Person说起。

描述人：Person；      属性：年龄；        行为：说话：说出自己的年龄。

package com.oracle.demo02;

public class person {
    //私有：private 关键字 把变量还有方法私有化，外界不能访问，只能在本类中访问
    //封装：隐藏实现细节，对外提供访问方式。
    private int age;
    private String name;
    public void setname(String n){
        name=n;
    }
    //取值的方法
    public String getname(){
        return name;
    }
    public int getage(){
        return age;
    }
    public void setage(int a){
        if(a>0 && a<120){
            age=a;
        }else{
            age=0;
        }
    }
    public void speak(){
        System.out.println("我叫"+name+"，今年"+age+"岁了");
    }

输出：

 

二、继承

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。

继承的格式&使用

在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

class 子类 extends 父类 {}

接下来通过一个案例来学习子类是如何继承父类的，如下所示。Example01.java

定义员工类Employee
class Employee {
    String name; // 定义name属性
    // 定义员工的工作方法
    public void work() {
        System.out.println("尽心尽力地工作");
    }
}
定义研发部员工类Developer 继承 员工类Employee
class Developer extends Employee {
    // 定义一个打印name的方法
    public void printName() {
        System.out.println("name=" + name);
    }
}
定义测试类
public class Example01 {
    public static void main(String[] args) {
        Developer d = new Developer(); // 创建一个研发部员工类对象
        d.name = "小明"; // 为该员工类的name属性进行赋值
        d.printName(); // 调用该员工的printName()方法
        d.work(); // 调用Developer类继承来的work()方法
    }
}

继承的好处&注意事项

继承的好处：

1、继承的出现提高了代码的复用性，提高软件开发效率。

2、继承的出现让类与类之间产生了关系，提供了多态的前提。

 继承的注意事项：

1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。

     class A{} 
     class B{}
     class C extends A,B{}  // C类不可以同时继承A类和B类

2、多个类可以继承一个父类，例如下面这种情况是允许的。

     class A{}
     class B extends A{}
     class C extends A{}   // 类B和类C都可以继承类A

 

3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。

 

     class A{}
     class B extends A{}   // 类B继承类A，类B是类A的子类
     class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

 

4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类。

继承-子父类中成员变量的特点

类的成员重点学习成员变量、成员方法的变化。

成员变量：如果子类父类中出现不同名的成员变量，这时的访问是没有任何问题。

看如下代码：

class Fu
{
    //Fu中的成员变量。
    int num = 5;
}
class Zi extends Fu
{
    //Zi中的成员变量
    int num2 = 6;
    //Zi中的成员方法
    public void show()
    {
        //访问父类中的num
        System.out.println("Fu num="+num);
        //访问子类中的num2
        System.out.println("Zi num2="+num2);
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Zi z = new Zi(); //创建子类对象
        z.show(); //调用子类中的show方法
    }
}

代码说明：Fu类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类是不能直接访问的。
当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。

在子类中，访问父类中的成员变量格式：
super.父类中的成员变量

看如下代码：

class Fu
{
    //Fu中的成员变量。
    int num = 5;
}
class Zi extends Fu
{
    //Zi中的成员变量
    int num = 6;
    void show()
    {
        //子父类中出现了同名的成员变量时
        //在子类中需要访问父类中非私有成员变量时，需要使用super关键字
        //访问父类中的num
        System.out.println("Fu num="+super.num);
        //访问子类中的num2
        System.out.println("Zi num2="+this.num);
    }
}
class Demo5 
{
    public static void main(String[] args) 
    {
        Zi z = new Zi(); //创建子类对象
        z.show(); //调用子类中的show方法
    }
}

 三、多态

    //在多态中成员方法的特点：
    //1.如果子类和父类有同名的方法，则调用子类重写后的方法
    //2.如果父类中没有同名的方法，那么该对象不能调用子类独有的方法
    //3.如果父类中有，而子类中没有的方法，那么调用父类的方法
    //在多态成员变量的特点：
    //1.如果子类和父类有同名的成员变量，则调用时访问的是父类的成员变量
    //2.如果父类中没有同名的成员变量，则该对象不能调用独有的成员变量
    //3.如果父类中有，而子类没有的成员变量，那么调用父类的成员变量

 1、 多态概述

（1）多态是继封装、继承之后，面向对象的第三大特性。

（2）现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

（3）Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

（4）Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值，又可以给这个子类(实现类对象)的父类(接口)变量赋值。

（5）如Student类可以为Person类的子类。那么一个Student对象既可以赋值给一个Student类型的引用，也可以赋值给一个Person类型的引用。

（6）最终多态体现为父类引用变量可以指向子类对象。

（7）多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。

（8）在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

 2、多态的定义与使用格式

 （1）多态的定义格式：就是父类的引用变量指向子类对象

父类类型  变量名 = new 子类类型();
变量名.方法名();

（2） 普通类多态定义的格式

父类 变量名 = new 子类();
如： public class Fu {}
    public class Zi extends Fu {}
    //类的多态使用
    Fu f = new Zi();

（3）抽象类多态定义的格式

抽象类 变量名 = new 抽象类子类();
如：  public  abstract class Fu {
       public abstract void method();
         }
     public class Zi extends Fu {
     public void method(){
              System.out.println(“重写父类抽象方法”);
     }
     }
     //类的多态使用
     Fu fu= new Zi();

（4）接口多态定义的格式

接口 变量名 = new 接口实现类();
如： public interface Fu {
             public abstract void method();
    }
    public class Zi implements Fu {
             public void method(){
              System.out.println(“重写接口抽象方法”);
    }
    }
     //接口的多态使用
     Fu fu = new Zi();

 

注意事项：同一个父类的方法会被不同的子类重写。在调用方法时，调用的为各个子类重写后的方法。

如 Person p1 = new Student();
   Person p2 = new Teacher();
   p1.work(); //p1会调用Student类中重写的work方法
   p2.work(); //p2会调用Teacher类中重写的work方法

当变量名指向不同的子类对象时，由于每个子类重写父类方法的内容不同，所以会调用不同的方法。

 3、instanceof关键字

    我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型。如学生的对象属于学生类，学生的对象也属于人类。

使用格式：

boolean  b  = 对象  instanceof  数据类型;

如：

Person p1 = new Student(); // 前提条件，学生类已经继承了人类
boolean flag = p1 instanceof Student; //flag结果为true
boolean flag2 = p1 instanceof Teacher; //flag结果为false

4、多态-转型

多态的转型分为向上转型与向下转型两种：

向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。

使用格式：

父类类型  变量名 = new 子类类型();
如：Person p = new Student();

向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的！

使用格式：

子类类型 变量名 = (子类类型) 父类类型的变量;
如:Student stu = (Student) p;  //变量p 实际上指向Student对象

5、多态的好处与弊端

        当父类的引用指向子类对象时，就发生了向上转型，即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型，提高了代码的扩展性。

        但向上转型也有弊端，只能使用父类共性的内容，而无法使用子类特有功能，功能有限制。

看如下代码

//描述动物类，并抽取共性eat方法
abstract class Animal {
    abstract void eat();
}
// 描述狗类，继承动物类，重写eat方法，增加lookHome方法
class Dog extends Animal {
    void eat() {
        System.out.println("啃骨头");
    }

    void lookHome() {
        System.out.println("看家");
    }
}
// 描述猫类，继承动物类，重写eat方法，增加catchMouse方法
class Cat extends Animal {
    void eat() {
        System.out.println("吃鱼");
    }
    void catchMouse() {
        System.out.println("抓老鼠");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal a = new Dog(); //多态形式，创建一个狗对象
        a.eat(); // 调用对象中的方法，会执行狗类中的eat方法
        // a.lookHome();//使用Dog类特有的方法，需要向下转型，不能直接使用
        
        // 为了使用狗类的lookHome方法，需要向下转型
// 向下转型过程中，可能会发生类型转换的错误，即ClassCastException异常
        // 那么，在转之前需要做健壮性判断 
        if( !a instanceof Dog){ // 判断当前对象是否是Dog类型
                 System.out.println("类型不匹配，不能转换"); 
                 return; 
        } 
        Dog d = (Dog) a; //向下转型
        d.lookHome();//调用狗类的lookHome方法
    }
}

总结：

1、什么时候使用向上转型：

当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型。

如：

Animal a = new Dog();

    a.eat();

 

2、什么时候使用向下转型

当要使用子类特有功能时，就需要使用向下转型。

如：

Dog d = (Dog) a; //向下转型

    d.lookHome();//调用狗类的lookHome方法

3、向下转型的好处：可以使用子类特有功能。

弊端是：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。

如：if( !a instanceof Dog){…}