Java系列——封装、继承、多态初了解

03-09 1534阅读

目录

一、前言

二、封装

1.什么是封装？  

2.封装的特点

3.封装的使用

三、继承

1.什么是继承？

2.继承的特点

3.继承的优点

4.继承的使用 

4.1 继承的格式

 4.2 继承的演示

4.3 成员变量

4.4 成员方法

4.5 构造方法

五、多态

1.什么是多态？

2.多态的特点

3.多态的使用 

4.引用类型转型

 5.为什么要做转型？

 六、总结

一、前言

         今天总结一下关于Java的三大特性，封装，继承，多态。其实关于三大特性对于从事编程人员来说都是基本的了，毕竟只要接触Java这些都是先要认识的，接下来就系统总结一下。

二、封装

1.什么是封装？  

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

  • 将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。
  • 通过该类提供的方法来实现对隐藏信息的操作和访问。
  • 隐藏对象的信息。
  • 留出访问的对外接口。

    ​ 举个比较通俗的例子，比如我们的USB接口。如果我们需要外设且只需要将设备接入USB接口中，而内部是如何工作的，对于使用者来说并不重要。而USB接口就是对外提供的访问接口。

    2.封装的特点

    • 对成员变量实行更准确的控制。
    • 封装可以隐藏内部程序实现的细节。
    • 良好的封装能够减少代码之间的耦合度。
    • 外部成员无法修改已封装好的程序代码。
    • 方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性。
    • 便于修改，体高代码的可维护性。

      3.封装的使用

              使用 private 关键字来修饰成员变量。对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。private是一个权限修饰符，代表最小权限， 可以修饰成员变量和成员方法， 被private修饰后的成员变量和成员方法，只在本类中才能访问。代码示例：

      public class Student {
  private String name;
  private int age;
 public void setName(String name) {
    this.name = name;
  } 
 public String getName() {
    return name;
  }
 public void setAge(int age) {
    this.age = age;
  } 
 public int getAge() {
    return age;
  }
}

      分析：对于上面的一个实体对象，我想大家都已经很熟悉了。将对象中的成员变量进行私有化，外部程序是无法访问的。但是我们对外提供了访问的方式，就是set和get方法。而对于这样一个实体对象，外部程序只有赋值和获取值的权限，是无法对内部进行修改，因此我们还可以在内部进行一些逻辑上的判断等，来完成我们业务上的需要。

      三、继承

      1.什么是继承？

      ​        继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

      2.继承的特点

      2.1 只支持单继承，一个子类只允许有一个父类

      2.2 子类可以拥有父类的属性和方法

      2.3 子类可以拥有自己的属性和方法

      2.4 子类可以重写父类的方法

      2.5 可以声明父类，创建子类（又称作为父类装载子类）

            例如：Person p=new Teacher();

                      (1) 声明什么样的类型，就只能调用什么类型的属性和方法

                      (2) 创建什么样的类型，就真正运行的什么类型的方法

                       提示： (1)和(2)称为向上转型， 例如：Person p=new Teacher();那么p只能调用Person类中的方法和属性，但实际上运行的是Teacher中所重写的方法，无法调用Teacher中的私有的方法

                      (3) 创建什么样的类型，就可以强转为什么类型

                       提示：例如： Person p=new Teacher();

                                             Teacher t=(Teacher) p;

                       这种叫做向下转型，此时t调用的是创建的Teacher类型的相应属性和方法。

      3.继承的优点

      • 提高代码发复用性
      • 父类的属性方法可以用于子类
      • 可以轻松定义子类
      • 使设计应用程序变得简单

        4.继承的使用 

        4.1 继承的格式

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

         4.2 继承的演示

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

        4.3 成员变量

                当成员变量不重名时，对代码的访问是没有影响的，但是当成员的变量重名时，这个时候访问就会出现问题，例如：

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

                子父类中出现同名的成员变量时，在子类中访问父类中的非私有成员变量时，需要使用super关键字来修饰父类成员变量，类似于this。例如：

        class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
//访问父类中的num
System.out.println("Fu num=" + super.num);
//访问子类中的num
System.out.println("Zi num=" + this.num);
}
} 
 
演示结果：
Fu num = 5
Zi num = 6

        4.4 成员方法

                当成员方法出现重名时，我们则需要用到方法重写（Override）。

                方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

        class Phone {
public void sendMessage(){
System.out.println("发短信");
} 
 
public void call(){
System.out.println("打电话");
}
 
public void showNum(){
System.out.println("来电显示号码");
 }
}
//智能手机类
class NewPhone extends Phone {
//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
public void showNum(){
//调用父类已经存在的功能使用super
super.showNum();
//增加自己特有显示姓名和图片功能
System.out.println("显示来电姓名");
System.out.println("显示头像");
}
} 
public class ExtendsDemo06 {
public static void main(String[] args) {
// 创建子类对象
NewPhone np = new NewPhone()；
// 调用父类继承而来的方法
np.call();
// 调用子类重写的方法
np.showNum();
}
}

        注意：这里在重写时，用到了super.父类成员方法，表示调用父类成员的方法。

        4.5 构造方法

                首先我们要回忆两个事情，构造方法的定义格式和作用。

                1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。

                2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

        class Fu {
 private int n;
 Fu(){
  System.out.println("Fu()");
  }
}
 
class Zi extends Fu {
  Zi(){
 // super（），调用父类构造方法
  super();
  System.out.println("Zi（）");
  }
} 
public class ExtendsDemo07{
  public static void main (String args[]){
  Zi zi = new Zi();
  }
}
 
输出结果：
Fu（）
Zi（）

        五、多态

        1.什么是多态？

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

        2.多态的特点

        1. 消除类型之间的耦合关系，实现低耦合
        2. 灵活性
        3. 可扩充性
        4. 可替换性

        3.多态的使用 

        多态体现的格式：

        父类类型 变量名 = new 子类对象；

        变量名.方法名();

        当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

        定义父类：

        public abstract class Animal {
    public abstract void eat();
}

        定义子类：

        class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
} 
 
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
}

        定义测试类：

        public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Cat c = new Cat();
        Dog d = new Dog();
        // 调用showCatEat
        showCatEat(c);
        // 调用showDogEat
        showDogEat(d);
        /*
        以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
        而执行效果一致
        */
        showAnimalEat(c);
        showAnimalEat(d);
    }
    public static void showCatEat (Cat c){
        c.eat();
    } 
    public static void showDogEat (Dog d){
        d.eat();
    } 
    public static void showAnimalEat (Animal a){
        a.eat();
    }
}

                由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。

                当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。

                不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。

                所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

        4.引用类型转型

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

        向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。

        使用格式

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

        如：Animal a = new Cat();

        向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

        一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

        使用格式：

        子类类型 变量名 = (子类类型) 父类变量名;

        如:Cat c =(Cat) a;

         5.为什么要做转型？

        当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

        定义类：

        abstract class Animal {
    abstract void eat();
} 
 
class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼"); 
    } 
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
} 
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void watchHouse() {
        System.out.println("看家");
    }
}

        定义测试类：

        public class Test {
    public static void main(String[] args) {
        // 向上转型
        Animal a = new Cat();
        a.eat(); // 调用的是 Cat 的 eat
        // 向下转型
        Cat c = (Cat)a;
        c.catchMouse(); // 调用的是 Cat 的 catchMouse
    }
}

        注意：此处在转换时，有时会出现转换异常的情况，例如：

        public class Test {
    public static void main(String[] args) {
        // 向上转型
        Animal a = new Cat();
        a.eat(); // 调用的是 Cat 的 eat
        // 向下转型
        Dog d = (Dog)a;
        d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
    }
}

                这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

        变量名 instanceof 数据类型

        如果变量属于该数据类型，返回true。

        如果变量不属于该数据类型，返回false。

        所以在转换前我们可以先做一个判断

        public class Test {
    public static void main(String[] args) {
        // 向上转型
        Animal a = new Cat();
        a.eat(); // 调用的是 Cat 的 eat
        // 向下转型
        if (a instanceof Cat){
            Cat c = (Cat)a;
            c.catchMouse(); // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;
            d.watchHouse(); // 调用的是 Dog 的 watchHouse
        }
    }
}

         六、总结

                以上就是小编收集的关于java的封装、继承、多态的知识点了，有问题的地方欢迎评论交流呀，期待和各位一起变强呀！！！Java系列——封装、继承、多态初了解

VPS购买请点击我

文章版权声明：除非注明，否则均为主机测评原创文章，转载或复制请以超链接形式并注明出处。

相关阅读

目录[+]