面向对象3种特性（封装，继承，多态）

Java封装，继承，多态

Java 封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

一、封装的优点

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

二、实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

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

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

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

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

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

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

以上实例中public方法是外部类访问该类成员变量的入口。

通常情况下，这些方法被称为getter和setter方法。

因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

Java继承

一、继承的概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

二、继承的优缺点

优点：

1.提高代码的复用性。

2.提高代码的可维护性。

3.提高开发效率。

缺点：

提高了类与类之间的耦合性。

三、类的继承格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的

class 父类 {
}
 
class 子类 extends 父类 {
}

四、继承的特性

1.子类拥有父类非private的属性，方法。

2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

3.子类可以用自己的方式实现父类的方法。(重写)

4.Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类。

//定义手机类
class Phone{
    //定义手机的价格
    double price = 500;
    //手机都能打电话
    public void call(){
        System.out.println("手机可以打电话");
    }
}
//定义具体的手机类：华为手机类，让其继承手机类Phone
class HuaWei extends Phone{
 
    //定义子类特有的方法，在子类中可以直接使用父类的非私有的成员变量
    public void show(){
        //输出父类中定义的手机的价格
        System.out.println(price);
    }
}
//定义测试类
class Test{
    public static  void main(String[] args){
        //创建子类对象
        HuaWei hw = new HuaWei();
        //因为继承了Phone类，所以继承了父类的属性和方法，所以可以调用父类中的call()方法
        hw.call();
        //调用子类特有的方法，输出父类中定义的手机价格
        hw.show();
        //子类对象也可以直接调用父类中非私有的成员变量
        System.out.println(hw.price);
    }
}

1、super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

//定义手机类
class Phone_2{
    //定义手机的价格
    double price = 500;
 
}
//定义具体的手机类：华为手机类，让其继承手机类Phone
class HuaWei_2 extends Phone_2{
    //定义手机的价格，变量名与父类相同
    double price = 600;
    //定义子类特有的方法
    public void show(){
        //这里会优先使用子类本身定义的变量price
        System.out.println(this.price);
        //输出父类的要使用super关键字调用
        System.out.println(super.price);
    }
}
//定义测试类
class Test_2{
    public static  void main(String[] args){
        //创建子类对象
        HuaWei_2 hw_2 = new HuaWei_2();
        //调用子类特有的方法，输出子类本身定义的手机价格，和父类中定义的价格
        hw_2.show();
 
//子类对象调用price
System.out.println(hw_2.price);
 
 
 
    }
}

2、重写

在子类中定义了与父类中一模一样的成员方法(权限大于或等于父类方法的权限)，此操作称之为方法重写。

当子类对象调用方法是，会优先调用自己重写后方法，如果没有重写，那么才会去调用父类中的方法。

//定义手机类
class Phone_3{
    //定义打电话方法
    public void call(){
        System.out.println("手机可以打电话！");
    }
}
//定义具体的手机类：华为手机类，让其继承手机类Phone
class HuaWei_3 extends Phone_3{
    //重写父类中的打电话方法
    @Override
    public void call() {
        //使用super关键字调用父类中的call方法
        super.call();
        System.out.println("华为手机当然可以打电话！");
    }
}
//定义测试类
class Test_3{
    public static  void main(String[] args){
        //创建子类对象
        HuaWei_3 hw_3 = new HuaWei_3();
        //优先调用子类重写后的方法
        hw_3.call();
    }
}

3、final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

• 声明类：

  final class 类名 {//类体}
  

• 声明方法：

  修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
  

Java多态

多态是同一个行为具有多个不同表现形式或形态的能力。

一、多态的优点

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

二、多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

//定义父类
public class Father {
    //定义方法
    public void fun(){
        System.out.println("我是父类中的方法！");
    }
 
}
//定义子类,继承父类
class Son extends Father{
    //重写父类中的方法
    @Override
    public void fun() {
        System.out.println("我是重写后的方法！");
    }
}
//测试类
class Test{
    public static void main(String[] args){
        //多态体现，父类引用指向子类对象
        Father f = new Son();
        //调用重写后的方法
        f.fun();
    }
}

三、向上、向下转型

向上转型：

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

向下转型：

一个已经向上转型的子类对象，使用强制类型转换，将父类引用转换为子类引用，这个过程称之为向下转型。（直接创建父类对象，无法向下转型）

//定义父类
public class Father_3 {
   //父类中的成员变量
    int a = 10;
    //定义方法
    public void fun(){
        System.out.println("我是父类中的方法！");
    }
}
//定义子类,继承父类
class Son_3 extends Father_3{
   //子类中的成员变量
    int a = 12;
    //重写父类中的方法
    @Override
    public void fun() {
        System.out.println("我是重写后的方法！");
    }
    //子类特有的方法
    public  void fun_2(){
        System.out.println("我是子类特有的方法！");
    }
}
//测试类
class Test_3{
    public static void main(String[] args){
        //多态体现，此过程为向上转型
        Father_3 f3 = new Son_3();
        //向下转型，强制转换
        Son_3 s3 = (Son_3)f3;
        //调用子类特有的成员
        s3.fun_2();
        System.out.println(s3.a);
    }
}

四、instanceof 运算符

instanceof是一个比较运算符，它用来判断一个引用类型是否属于某个类型(要有继承和实现关系)的对象。

//定义“人”类
public class Person {
 
    public  void eat(){
        System.out.println("人都要吃饭！");
    }
 
}
//定义“我” 类，继承“人”类
class My extends Person{
 
    public void eat(){
        System.out.println("我是人，我也要吃饭！");
    }
 
}
//定义测试类
class Test_4{
    public static void main(String[] args) {
        //多态体现
        Person p = new My();
        //判断p 是否属于Person类型
        if (p instanceof Person) {
            System.out.println(true);
        }
        //判断p 是否属于 My 类型
        if (p instanceof My) {
            System.out.println(true);
        }
    }
}