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

这篇具有很好参考价值的文章主要介绍了Java系列——封装、继承、多态初了解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、前言

二、封装

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,java文章来源地址https://www.toymoban.com/news/detail-718408.html

到了这里,关于Java系列——封装、继承、多态初了解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Java初阶(六)上】封装 继承 多态

    ❣博主主页: 33的博客❣ ▶文章专栏分类: Java从入门到精通◀ 🚚我的代码仓库: 33的代码仓库🚚 对于面向对象程序三大特性:封装、继承、多态。这篇文章将会详细讲解到如何实现封装、继承、多态,以及具体的应用。 本章重点 掌握封装的概念,如何实现封装,包的概念,继

    2024年04月09日
    浏览(45)
  • Educoder/头歌JAVA——JAVA面向对象:封装、继承和多态的综合练习

    目录 第1关:封装、继承和多态进阶(一) 相关知识 面向对象思想 封装 继承 组合和继承 构造函数 super()和this() 编程要求 第2关:封装、继承和多态进阶(二) 相关知识 重写和重载 abstract(抽象类)和interface(接口) final static static的作用 多态 编程要求 第

    2024年02月04日
    浏览(55)
  • 图书管理借阅系统【Java简易版】Java三大特征封装,继承,多态的综合运用

    前言 前几篇文章讲到了Java的基本语法规则,今天我们就用前面学到的数组,类和对象,封装,继承,多态,抽象类,接口等做一个图书管理借阅系统。 Java语言是面向对象的,所以首先要分析完成这个图书管理系统,有哪些对象: 👱使用者User 📘书Book 📲操作Operation 使用者

    2024年02月14日
    浏览(44)
  • 01 java 学习 数据类型、基础语法、封装、继承、多态、接口、泛型、异常等

    目录 环境搭建和基础知识  什么是JRE: 什么是JDK: 基础数据类型  分支选择if else switch和c一毛一样 for和while循环还有数组基本和c一样 封装 函数调用、传参、命名规范、数组新命名规范 java输入Scanner scanner = new Scanner(System.in); 类的创建和使用以及封装修饰符  构造方法:含义、

    2024年02月11日
    浏览(42)
  • 【Java SE语法篇】8.面向对象三大特征——封装、继承和多态

    📚博客主页:爱敲代码的小杨. ✨专栏:《Java SE语法》 ❤️感谢大家点赞👍🏻收藏⭐评论✍🏻,您的三连就是我持续更新的动力❤️ 面向对象三大特性:封装、继承和多态。 在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部

    2024年02月01日
    浏览(59)
  • c、c++、java、python、js对比【面向对象、过程;解释、编译语言;封装、继承、多态】

    目录 内存管理、适用 区别 C 手动内存管理:C语言没有内置的安全检查机制,容易出现内存泄漏、缓冲区溢出等安全问题。 适用于系统级编程 C++ 手动内存管理:C++需要程序员手动管理内存,包括分配和释放内存,这可能导致内存泄漏和指针错误。 适用于游戏引擎和系统级编

    2024年02月08日
    浏览(76)
  • 【Java0基础学Java第八颗】 -- 继承与多态 -- 多态

    通俗来说就是多种形态, 具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态 。 就比如打印机,彩色打印机和黑白打印机,打印出的效果一个是彩色,一个是黑白。 即: 同一件事情,发生在不同对象身上,就会产生不同的结果 。 在Java中要实现多态,

    2024年02月04日
    浏览(44)
  • (java)继承和多态 (详解)

    目录 1 继承 1.1为什么需要继承 1.2 继承概念 1.3 继承的语法 1.4 父类成员访问  1.4.1 子类中访问父类的成员变量 1.4.2 子类中访问父类的成员方法   1.5 super 1.6 子类构造方法 1.7 super和this 1.7.1 this 1.7.2 super和this  1.8 再谈初始化 1.9 继承方式 1.10 继承与组合 2 多态 2.1 多态

    2024年02月03日
    浏览(41)
  • Java之继承和多态

    1.  为什么需要继承 先看下代码 // Dog.java public class Dog { string name ; int age ; float weight ; public void eat (){ System . out . println ( name + \\\" 正在吃饭 \\\" ); } public void sleep (){ System . out . println ( name + \\\" 正在睡觉 \\\" ); } void Bark (){ System . out . println ( name + \\\" 汪汪汪 ~~~\\\" ); } } // Cat.Java public class Ca

    2024年04月23日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包