Java面向对象三大特性之(封装和继承)以及抽象类、模板设计模式、final关键字

最新推荐文章于 2021-04-15 11:53:39 发布

「已注销」

最新推荐文章于 2021-04-15 11:53:39 发布

阅读量182

点赞数

本文链接：https://blog.csdn.net/weixin_46146561/article/details/103864852

版权

封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。例如使用private关键字封装属性,我们就得通过类中指定的set\get方法来访问,接下来我们就来回顾一下如何使用private关键字对属性的封装.

路径:

封装的步骤
封装的实现

讲解:

1.3.1 封装的步骤

1.使用 private 关键字来修饰成员变量。

2.使用public修饰getter和setter方法。

1.3.2 封装的步骤实现

private修饰成员变量

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

public修饰getter和setter方法

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

    public void setName(String n) {
   
      	name = n;
    }

    public String getName() {
   
      	return name;
    }

    public void setAge(int a) {
   
        if (a > 0 && a <200) {
   
            age = a;
        } else {
   
            System.out.println("年龄非法！");
        }
    }

    public int getAge() {
   
      	return age;
    }
}

小结:

使用private关键字修饰成员变量
为使用private修饰的成员变量提供公共的set\get方法

知识点-- 构造方法

目标:

路径:

构造方法的作用
构造方法的格式
构造方法的应用

讲解:

1.4.1 构造方法的作用

通过调用构造器可以返回一个类的对象，构造器同时负责帮我们把对象的数据（属性和行为等信息）初始化好。

1.4.2 构造方法的格式

修饰符 类名(形参列表) {
   
    // 构造体代码，执行代码
}

1.4.3 构造方法的应用

首先定义一个学生类，代码如下：

public class Student {
   
    // 1.成员变量
    public String name;
    public int age;

    // 2.构造器
    public Student() {
   
		System.out.println("无参数构造器被调用")；
    }
}

构造方法主要用来创建类的对象,以及给创建出来的对象初始化

构造方法的格式:

修饰符 类名(形参列表) {
     
    // 构造体代码，执行代码
}

知识点-- 如何通过类创建对象

讲解:

类名 对象名称 = new 类名(形参);

接下来通过调用构造器得到两个学生对象。

public class CreateStu02 {
   
    public static void main(String[] args) {
   
        // 创建一个学生对象
        // 类名 变量名称 = new 类名();
        Student s1 = new Student();
        // 使用对象访问成员变量，赋值
        s1.name = "张三";
        s1.age = 20 ;

        // 使用对象访问成员变量 输出值
        System.out.println(s1.name);
        System.out.println(s1.age); 

        Student s2 = new Student();
        // 使用对象访问成员变量 赋值
        s2.name = "李四";
        s2.age = 18 ;
        System.out.println(s2.name);
        System.out.println(s2.age);
    }
}

小结:

通过new 调用构造方法就可以创建对象

知识点-- this关键字的作用

路径:

this关键字的作用
this关键字的应用

讲解:

1.5.1 this关键字的作用

this代表所在类的当前对象的引用（地址值），即代表当前对象。用来区分同名的成员变量和局部变量

1.5.2 this关键字的应用

1.5.2.1 用于普通的gettter与setter方法

this出现在实例方法中，谁调用这个方法（哪个对象调用这个方法），this就代表谁（this就代表哪个对象）。

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) {
   
        if (age > 0 && age < 200) {
   
            this.age = age;
        } else {
   
            System.out.println("年龄非法！");
        }
    }

    public int getAge() {
   
      	return age;
    }
}

1.5.2.2 用于构造器中

this出现在构造器中，代表构造器正在初始化的那个对象。

public class Student {
   
    private String name;
    private int age;
    
    // 无参数构造方法
    public Student() {
   } 
    
    // 有参数构造方法
    public Student(String name,int age) {
   
    	this.name = name;
    	this.age = age; 
    }
}

第二章继承

知识点-- 概述

现实中的“继承”指“儿子”继承了“父亲”的财产, 也就是子承父业。在java中指的是“一个类”可以“继承自”“另一个类”。

路径:

为什么要有继承
继承的含义
继承的好处

讲解:

2.1.1 为什么要有继承

现实生活中，为什么要有继承？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KHrHj6yN-1578315756756)(imgs\1574219808378.png)]

程序中为什么要有继承呢？

假如我们要定义如下类:
学生类,老师类，分析如下：

学生类（Student）
属性:姓名,年龄
行为:吃饭,睡觉
老师类（Teacher）
属性:姓名,年龄，薪水
行为:吃饭,睡觉，教书

如果我们定义了这三个类去开发一个系统，那么这三个类中就存在大量重复的信息（属性:姓名，年龄。行为：吃饭，睡觉）。这样就导致了相同代码大量重复，代码显得很臃肿和冗余，那么如何解决呢？-----使用继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cqd5s0nE-1578315756757)(imgs\1574220305488.png)]

结论：假如多个类中存在相同属性和行为时，我们可以将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。

其中，多个类可以称为子类，单独被继承的那一个类称为父类、超类（superclass）或者基类。

2.1.2 继承的含义

继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

2.1.3 继承的好处

提高代码的复用性（减少代码冗余，相同代码重复利用）。
使类与类之间产生了关系。

小结:

继承：就是子类继承父类的属性和方法，使得子类对象可以直接具有与父类相同的属性、相同的方法。
继承的好处:
- 提高代码的复用性
- 让类与类之间产生关系
- 是实现多态的前提条件之一

知识点-- 继承的格式

路径:

继承的格式
继承的演示

讲解:

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
   
	...
}

class 子类 extends 父类 {
   
	...
}

需要注意：Java是单继承的，一个类只能继承一个直接父类，跟现实世界很像，但是Java中的子类是更加强大的。

小结:

实现继承需要使用extends关键字

继承的格式:
    public class 类A extends 类B{
     

    }

    类A 就是子类名
    类B 就是父类名

案例-- 继承案例

需求:

请使用继承定义以下类:

学生类
属性:姓名,年龄
行为:吃饭,睡觉
老师类
属性:姓名,年龄，薪水
行为:吃饭,睡觉，教书
班主任
属性:姓名,年龄，薪水
行为:吃饭,睡觉，管理
Person父类
1. 属性:姓名,年龄
2. 行为:吃饭,睡觉

分析

老师类，学生类，还有班主任类，实际上都是属于人类的，我们可以定义一个人类，把他们相同的属性和行为都定义在人类中，然后继承人类即可，子类特有的属性和行为就定义在子类中了。

如下图所示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A2alSVBd-1578315756757)(imgs/360截图20181202211331250.jpg)]

实现:

1.父类Human类

 public class Human {
   
    // 合理隐藏
    private String name ;
    private int age ;
	
    // 合理暴露
    public String getName() {
   
        return name;
    }

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

    public int getAge() {
   
        return age;
    }

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

2.子类Teacher类

public class Teacher extends Human {
   
    // 工资
    private double salary ;
    
    // 特有方法
    public void teach(){
   
        System.out.println("老师在认真教技术！")；
    }

    public double getSalary() {
   
        return salary;
    }

    public void setSalary(double salary) {
   
        this.salary = salary;
    }
}

3.子类Student类

public class Student extends Human{
   
 
}

4.子类BanZhuren类

public class Teacher extends Human {
   
    // 工资
    private double salary ;
    
       // 特有方法
    public void admin(){
   
        System.out.println("班主任强调纪律问题！")；

最低0.47元/天解锁文章

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象三大特性之(封装和继承)以及抽象类、模板设计模式、final关键字

封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。例如使用private关键字封装属性,我们就得通过类中指定的set\get方法来访问,接下来我们就来回顾一下如何使用private关键字对属性的封装.路径:封装的步骤封装的实现讲解:1.3.1 封装的步骤1.使用 private 关键字来修饰成员变量。2.使用public...
复制链接

扫一扫