一,前言

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

二,封装

​ 先来说说特性之一:封装

2.1,什么是封装

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

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

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

​ 说了这么多,那为什么使用封装?

2.2,封装的特点

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

2.3,封装的使用

  • 使用private修饰符,表示最小的访问权限。

  • 对成员变量的访问,统一提供setXXX,getXXX方法。

    下面请看一个Student实体对象类:

    public class Student implements Serializable {
    
        private Long id;
    private String name;
    private Integer sex; public Long getId() {
    return id;
    } public void setId(Long id) {
    this.id = id;
    } public String getName() {
    return name;
    } public void setName(String name) {
    this.name = name;
    } public Integer getSex() {
    return sex;
    } public void setSex(Integer sex) {
    this.sex = sex;
    }
    }

    分析:对于上面的一个实体对象,我想大家都已经很熟悉了。将对象中的成员变量进行私有化,外部程序是无法访问的。但是我们对外提供了访问的方式,就是set和get方法。

    ​ 而对于这样一个实体对象,外部程序只有赋值和获取值的权限,是无法对内部进行修改,因此我们还可以在内部进行一些逻辑上的判断等,来完成我们业务上的需要。

    ​ 到这里应该就明白封装对于我们的程序是多么重要。下面再来说说继承的那点事。

    三,继承

    3.1,什么是继承

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

    3.2,继承的特点

    1,关于继承的注意事项:

    ​ 只支持单继承,即一个子类只允许有一个父类,但是可以实现多级继承,及子类拥有唯一的父类,而父类还可以再继承。

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

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

    ​ 子类可以重写覆盖父类的方法。

    2,继承的特点:

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

    3.3,继承的使用

    1,在父子类关系继承中,如果成员变量重名,则创建子类对象时,访问有两种方式。

    a,直接通过子类对象访问成员变量

    ​ 等号左边是谁,就优先使用谁,如果没有就向上找。

    b,间接通过成员方法访问成员变量

    该方法属于谁,谁就优先使用,如果没有就向上找。

    public class FU {
    int numFU = 10;
    int num = 100;
    public void method(){
    System.out.println("父类成员变量:"+numFU);
    }
    public void methodFU(){
    System.out.println("父类成员方法!");
    }
    }
    public class Zi extends FU{
    int numZi = 20;
    int num = 200;
    public void method(){
    System.out.println("子类成员变量:"+numFU);
    }
    public void methodZi(){
    System.out.println("子类方法!");
    }
    }
    public class ExtendDemo {
    public static void main(String[] args) {
    FU fu = new FU();
    // 父类的实体对象只能调用父类的成员变量
    System.out.println("父类:" + fu.numFU); // 结果:10 Zi zi = new Zi();
    System.out.println("调用父类:" + zi.numFU); // 结果:10
    System.out.println("子类:" + zi.numZi); // 结果:20 /** 输出结果为200,证明在重名情况下,如果子类中存在则优先使用,
    * 如果不存在则去父类查找,但如果父类也没有那么编译期就会报错。
    */
    System.out.println(zi.num); // 结果:200
    /**
    * 通过成员方法调用成员变量
    */
    zi.method(); // 结果:10
    }
    }

    2,同理:

    ​ 成员方法也是一样的,创建的对象是谁,就优先使用谁,如果没有则直接向上找。

    注意事项:

    ​ 无论是成员变量还是成员方法,如果没有都是向上父类中查找,绝对不会向下查找子类的。

    3,在继承关系中,关于成员变量的使用:

    ​ 局部成员变量:直接使用

    ​ 本类成员变量:this.成员变量

    ​ 父类成员变量:super.父类成员变量

    int numZi = 10;
    public void method() {
    int numMethod = 20;
    System.out.println(numMethod); // 访问局部变量
    System.out.println(this.numZi); // 访问本类成员变量
    System.out.println(super.numFu); // 访问本类成员变量
    }

    3.4,重写,重载

    重写(override)

    ​ 是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!

    class Animal{
    public void move(){
    System.out.println("动物行走!");
    }
    } class Dog extends Animal{
    public void move(){
    System.out.println("狗可以跑和走");
    }
    } public class TestDog{
    public static void main(String args[]){
    Animal a = new Animal(); // Animal 对象
    Animal b = new Dog(); // Dog 对象
    a.move();// 执行 Animal 类的方法
    b.move();//执行 Dog 类的方法
    }
    }

    ​ 重写的规则:

    ​ 1,参数列表必须与被重写方法相同。

    ​ 2,访问权限不能比父类中被重写的方法的访问权限更低(public>protected>(default)>private)。

    ​ 3,父类成员的方法只能被它的子类重写。

    ​ 4,被final修饰的方法不能被重写。

    ​ 5,构造方法不能

    重载(overload)

    ​ 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。

    ​ 最常用的地方就是构造器的重载。

   public class Overloading {
public int test(){
System.out.println("test1");
return 1;
}
public void test(int a){
System.out.println("test2");
}
//以下两个参数类型顺序不同
public String test(int a,String s){
System.out.println("test3");
return "returntest3";
}
public String test(String s,int a){
System.out.println("test4");
return "returntest4";
}
public static void main(String[] args){
Overloading o = new Overloading();
System.out.println(o.test());
o.test(1);
System.out.println(o.test(1,"test3"));
System.out.println(o.test("test4",1));
}
}

​ 重载规则:

​ 1,被重载的方法必须改变参数列表(参数个数或者类型不一样)。

​ 2,被重载的方法可以改变返回类型。

​ 3,被重载的方法可以改变访问修饰符。

3.5,this,super关键字

super()关键字的用法

​ 1,子类的成员方法中,访问父类的成员变量。

​ 2,子类的成员方法中,访问父类的成员方法。

3,子类的构造方法中,访问父类的构造方法。

this关键字用法:

​ 1,本类成员方法中,访问本类的成员变量。

​ 2,本类成员方法中,访问本类的另一个成员方法。

3,本类的构造方法中,访问本类的另一个构造方法。

​ 注意:

  • this关键字同super一样,必须在构造方法的第一个语句,且是唯一的。
  • this与super不能同时存在。

3.6,构造器

继承关系中,父子类构造方法的访问特点:

​ 1,在子类构造方法中有一个默认隐含的super();调用,因此一定是先调用父类构造方法,再调用子类构造方法。

​ 2,子类构造可以通过super();调用父类的重载构造。(重载)

​ 3,super();的父类调用构造方法,必须在子类构造中的第一行,就是第一个;号结束的元素,并且只能调用一次。

3.7,关于继承的注意事项:

​ 1,Java语言是单继承的,一个子类只能有唯一一个父类

​ 2,Java语言可以是多级继承,一个子类有一个父类,一个父类还可以有一个父类。

​ 3,一个子类只有一个父类,但是一个父类可以有多个子类。

四,多态

4.1,什么是多态

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

4.2,多态的特点

​ 1,消除类型之间的耦合关系,实现低耦合。

​ 2,灵活性。

​ 3,可扩充性。

​ 4,可替换性。

4.3,多态的体现形式

  • 继承

  • 父类引用指向子类

  • 重写

    注意:在多态中,编译看左边,运行看右边

   public class MultiDemo {
public static void main(String[] args) {
// 多态的引用,就是向上转型
Animals dog = new Dog();
dog.eat(); Animals cat = new Cat();
cat.eat(); // 如果要调用父类中没有的方法,则要向下转型
Dog dogDown = (Dog)dog;
dogDown.watchDoor(); }
}
class Animals {
public void eat(){
System.out.println("动物吃饭!");
}
}
class Dog extends Animals{
public void eat(){
System.out.println("狗在吃骨头!");
}
public void watchDoor(){
System.out.println("狗看门!");
}
}
class Cat extends Animals{
public void eat(){
System.out.println("猫在吃鱼!");
}
}

4.4,向上转型

1,格式:父类名称 对象名 = new 子类名称();
含义:右侧创建一个子类对象,把它当作父类来使用。
注意:向上转型一定是安全的。
缺点:一旦向上转型,子类中原本特有的方法就不能再被调用了。

五,接口

​ 最后,关于接口方面的细节,不同版本之间的区别。

问题描述:

​ 现在接口中需要抽取一个公有的方法,用来解决默认方法中代码重复的问题。

​ 但是这个共有的方法不能让实现类实现,所以应该设置为私有化。

在JDK8之后:

​ 1,default修饰,接口里允许定义默认的方法,但默认方法也可以覆盖重写。

​ 2,接口里允许定义静态方法。

在JDK9之后:

​ 1,普通私有方法,解决多个默认方法之间代码重复的问题。

​ 2,静态私有化,解决多个静态方法之间代码重复问题。

接口的注意事项:

​ 1,不能通过接口的实现类对象去调用接口中的静态方法。

​ 正确语法:接口名称调用静态方法。

接口当中的常量的使用:

​ 1,接口当中定义的常量:可以省略public static final。

​ 2,接口当中定义的常量:必须进行赋值。

​ 3,接口当中定义的常量:常量的名称要全部大写,多个名称之间使用下划线进行分割。

使用接口的注意事项:

​ 1,接口是没有静态代码块或者构造方法

​ 2,一个类的直接父类是唯一的,但是一个类可以同时实现多个接口。

​ 3,如果实现类没有覆盖重写接口中所有的抽象方法,那么实现类就必须是一个抽象类

​ 4,如果实现类中实现多个接口,存在重复的抽象方法,那么只需要覆盖重写一次即可。

​ 5,在Java中,如果实现类的直接继承父类与实现接口发生冲突时,父类优先级高于接口。

接口之间的关系:

​ 1,多个接口之间是继承关系。

​ 2,多个父接口当中默认方法如果重复,那么子接口必须进行默认方法的覆盖重写。

六,总结

​ 关于Java的特性基本总结完毕,当然还有一些细节没有完善。其实对于这些Java基础一定要掌握并熟记,因为这与我们的实际开发密切相关,好的编码习惯才能铸就好的产品,才能被社会认可。

​ 以上总结均是自己学习所得,如有不适之处,还请留言(邮箱)指教。

感谢阅读!

Java之封装,继承,多态的更多相关文章

  1. java面向对象(封装-继承-多态)

    框架图 理解面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能行为 面向对象将功能封装进对象,强调具备了功能的对象. 面向对象是基于面向过程的. 面向对象的特点 ...

  2. Java三大特性(封装,继承,多态)

    Java中有三大特性,分别是封装继承多态,其理念十分抽象,并且是层层深入式的. 一.封装 概念:封装,即隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别:将抽象得到的数据 ...

  3. Java基础——面向对象(封装——继承——多态 )

    对象 对象: 是类的实例(实现世界中 真 实存在的一切事物 可以称为对象) 类: 类是对象的抽象描述 步骤: 1.定义一个类 (用于 描述人:) ( * 人:有特征和行为) 2.根据类 创建对象 -- ...

  4. 浅谈学习C++时用到的【封装继承多态】三个概念

    封装继承多态这三个概念不是C++特有的,而是所有OOP具有的特性. 由于C++语言支持这三个特性,所以学习C++时不可避免的要理解这些概念. 而在大部分C++教材中这些概念是作为铺垫,接下来就花大部分 ...

  5. php面向对象 封装继承多态 接口、重载、抽象类、最终类总结

    1.面向对象 封装继承多态  接口.重载.抽象类.最终类 面向对象 封装继承多态  首先,在解释面向对象之前先解释下什么是面向对象? [面向对象]1.什么是类? 具有相同属性(特征)和方法(行为)的一 ...

  6. Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态)

    Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态) 1.面向对象的三大特性: (1)继承 ​ 继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以 ...

  7. OOP三大核心封装继承多态

    OOP支柱 3 个核心:封装 继承 多态 封装就是将实现细节隐藏起来,也起到了数据保护的作用. 继承就是基于已有类来创建新类可以继承基类的核心功能. 在继承中 另外一种代码重用是:包含/委托,这种重用 ...

  8. python面向对象(封装,继承,多态)

    python面向对象(封装,继承,多态) 学习完本篇,你将会深入掌握 如何封装一个优雅的借口 python是如何实现继承 python的多态 封装 含义: 1.把对象的属性和方法结合成一个独立的单位, ...

  9. java四大特性理解(封装继承多态抽象)

    封装: 封装是把过程和数据包围起来,对数据的访问只能通过已定义的接口.面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治.封装的对象,这些对象通过一个受保护的接口访问其他对象.封装是一 ...

  10. -1-2 java 面向对象基本概念 封装继承多态 变量 this super static 静态变量 匿名对象 值传递 初始化过程 代码块 final关键字 抽象类 接口 区别 多态 包 访问权限 内部类 匿名内部类 == 与 equal

    java是纯粹的面向对象的语言 也就是万事万物皆是对象 程序是对象的集合,他们通过发送消息来相互通信 每个对象都有自己的由其他的对象所构建的存储,也就是对象可以包含对象 每个对象都有它的类型  也就是 ...

随机推荐

  1. MyBatis映射,抛出Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'oid' in 'class java.lang.String'

    原因在于: 在MyBatis中使用动态语句的判断时,传入的参数(parameterType)为Java基本数据类型,获取的结果(resultType)为JavaBean对象,此时就会抛出该异常,此时可 ...

  2. Kotlin学习快速入门(4)——集合使用

    List,Set,Map都是集合 List 是一个有序集合,可通过索引(反映元素位置的整数)访问元素.元素可以在 list 中出现多次.列表的一个示例是一句话:有一组字.这些字的顺序很重要并且字可以重 ...

  3. 前端js性能优化的要点

    1 尽量少使用全局查找,比如全局变量,如果要多次使用,可以将全局变量存为局部变量再使用 eg:function(){ var body=document.body; alert(body): body ...

  4. git删除分支步骤

    在本地删除一个分支: git branch -D <本地分支> 在github远程端删除一个分支: git push origin :<远程端分支> 唯一不同的就是冒号代表了删 ...

  5. 改 Anaconda Jupyter Notebook 开发文件保存目录

    1.打开cmd,输入命令找到配置文件路径 jupyter notebook --generate-config 2.打开 jupyter_notebook_config.py 修改配置 c.Noteb ...

  6. linux CPU100%异常排查

    1.top查找出占CPU比例最高的进程(5881): 2.查看该进程正在执行的线程: top -H -p  5881 3.将线程转换成16进制 printf ‘%x\n’ 5950 4.查看异常线程执 ...

  7. 消息中间件-activemq实战之消息持久化(六)

    对于activemq消息的持久化我们在第二节的时候就简单介绍过,今天我们详细的来分析一下activemq的持久化过程以及持久化插件.在生产环境中为确保消息的可靠性,我们肯定的面临持久化消息的问题,今天 ...

  8. pythonday06数据类型(四)

    今日内容 1.集合 2内存相关 1.集合set 无序 无重复 v = {1,2,3,4,5,6,99,100} # 疑问:v = {} """ None int v1 = ...

  9. SonarQube系列三、Jenkins集成SonarQube(dotnetcore篇)

    [前言] 本系列主要讲述sonarqube的安装部署以及如何集成jenkins自动化分析.netcore项目.目录如下: SonarQube系列一.Linux安装与部署 SonarQube系列二.分析 ...

  10. 浅谈IDEA集成SSM框架(SpringMVC+Spring+MyBatis)

    前言 学习完MyBatis,Spring,SpringMVC之后,我们需要做的就是将这三者联系起来,Spring实现业务对象管理,Spring MVC负责请求的转发和视图管理, MyBatis作为数据 ...