Java封装、继承、多态

最新推荐文章于 2021-06-23 17:23:23 发布
最新推荐文章于 2021-06-23 17:23:23 发布
阅读量95 收藏 1
点赞数
分类专栏： java基础 文章标签： java 封装 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35996924/article/details/112508570
版权

Java封装、继承、多态

一、封装

1.1 封装概述
  • 概述：面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。 封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
  • 原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。
1.2 封装的步骤
  • 使用 private 关键字来修饰成员变量。
  • 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx方法。
1.3 封装的操作——private关键字

private的含义:

  • private是一个权限修饰符，代表最小权限。
  • 可以修饰成员变量和成员方法。
  • 被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式:

private 数据类型 变量名;

  • 使用 private 修饰成员变量。

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

  • 提供 getXxx 方法 / setXxx 方法，可以访问成员变量。

    public class Student {
    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;
    }
}

this的含义:

  • this代表所在类的当前对象的引用（地址值），即对象自己的引用。

    记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

this使用格式:

this.成员变量名;

使用 this 修饰方法中的变量，解决成员变量被隐藏的问题。
方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。

1.4 封装——构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法， 一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

构造方法的定义格式：

修饰符 构造方法名(参数列表){ // 方法体 }

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。

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

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

注意事项

  • 如果不提供构造方法，系统会给出无参数构造方法。
  • 如果提供了构造方法，系统将不再提供无参数构造方法。
  • 构造方法是可以重载的，既可以定义参数，也可以不定义参数。
1.5 标准代码——JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get方法。

public class ClassName{ 
	//成员变量  
	//无参构造方法【必须】 
	//有参构造方法【建议】 
	//成员方法 
	//getXxx() 
	//setXxx() 
}

编写符合 JavaBean 规范的类，以学生类为例：

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

    //构造方法
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

测试类：

public static void main(String[] args) {
    //无参构造使用
    Student s = new Student();
    s.setName("柳岩");
    s.setAge(18);
    System.out.println(s.getName() + "‐‐‐" + s.getAge());
    //带参构造使用
    Student s2 = new Student("赵丽颖", 18);
    System.out.println(s2.getName() + "‐‐‐" + s2.getAge());
}
//结果
柳岩‐‐‐18
赵丽颖‐‐‐18

二、继承

2.1 概述
  • 由来：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可。

在这里插入图片描述

  • 其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。
  • 继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，图中兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

定义:

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

好处:

  • 提高代码的复用性。
  • 类与类之间产生了关系，是多态的前提。
2.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类:

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

示例：

/**
 * 定义员工类Employee，做为父类
 */
public class Employee {
    //定义name属性
    String name;

    //定义员工的工作方法
    public void work() {
        System.out.println("尽心尽力地工作");
    }
}

/**
 * 定义老师类Teacher 继承员工类Employee	
 */
public class Teacher extends Employee {
    //定义一个打印name的方法
    public void printName() {
        System.out.println("name=" + name);
    }
}

/**
 * 测试类
 */
public class ExtendsDemo01 {
    public static void main(String[] args) {
        // 创建一个老师类对象
        Teacher t = new Teacher();
        // 为该员工类的name属性进行赋值
        t.name = "小明";
        // 调用该员工的printName()方法
        t.printName();//name=小明
        //调用Teacher类继承来的work()方法
        t.work(); //尽心尽力地工作
    }
}
//结果
name=小明
尽心尽力地工作
2.3 继承后的特点——成员变量

当类之间产生了关系后，其中各类中的成员变量，又产生了哪些影响呢？
成员变量不重名：

  • 如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

    public class Fu {
    //Fu中的成员变量
    int num = 5;
}

    public class Zi extends Fu {
    //Zi中的成员变量
    int num2 = 6;

    // Zi中的成员方法
    public void show() {
        //访问父类中的num
        System.out.println("Fu num=" + num); //继承而来，所以直接访问
        //访问子类中的num2
        System.out.println("Zi num2=" + num2);
    }
}

    public class ExtendDemo02 {
    public static void main(String[] args) {
        //创建子类对象 
        Zi z = new Zi();
        // 调用子类中的show方法 
        z.show();
    }
}
//结果
Fu num=5
Zi num2=6

成员变量重名：

  • 如果子类父类中出现重名的成员变量，这时的访问是有影响的。

    public class Fu {
    //Fu中的成员变量
    int num = 5;
}

    public class Zi extends Fu {
    //Zi中的成员变量
    int num = 6;

    // Zi中的成员方法
    public void show() {
        //访问父类中的num
        System.out.println("Fu num=" + num);
        //访问子类中的num2
        System.out.println("Zi num=" + num);
    }
}

    public class ExtendDemo03 {
    public static void main(String[] args) {
        //创建子类对象
        Zi z = new Zi();
        // 调用子类中的show方法
        z.show();
    }
}
//结果
Fu num=6
Zi num=6

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

    • 使用格式：

      super.父类成员变量名

    • 子类方法需要修改:

      public 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

    Fu类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能 直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？可以在父类中提供公共的getXxx方法和setXxx方法。

2.4 继承后的特点——成员方法

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？
成员方法不重名：

  • 如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

    class Fu {
    public void show() {
        System.out.println("Fu类中的show方法执行");
    }
}

class Zi extends Fu {
    public void show2() {
        System.out.println("Zi类中的show2方法执行");
    }
}

public class ExtendsDemo04 {
    public static void main(String[] args) {
        Zi z = new Zi();
        //子类中没有show方法，但是可以找到父类方法去执行
        z.show();
        z.show2();
    }
}
//结果
Fu类中的show方法执行
Zi类中的show2方法执行

成员方法重名——重写(Override):

  • 如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

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

    class Fu {
    public void show() {
        System.out.println("Fu show");
    }
}

class Zi extends Fu {
    //子类重写了父类的show方法
    @Override
    public void show() {
        System.out.println("Zi show");
    }
}

public class ExtendsDemo05 {
    public static void main(String[] args) {
        Zi z = new Zi();
        //子类中有show方法，只执行重写后的show方法
        z.show(); // Zi show
    }
}
//结果
Zi show

重写的应用：

  • 子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。比如新的手机增加来电显示头像的功能。

    class Phone {
    public void sendMessage() {
        System.out.println("发短信");
    }

    public void call() {
        System.out.println("打电话");
    }

    public void showNum() {
        System.out.println("来电显示号码");
    }
}

//智能手机类
class NewPhone extends Phone {
    //重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
    @Override
    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.父类成员方法，表示调用父类的成员方法。

注意事项

  • 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
  • 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。
2.5 继承后的特点——构造方法

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

  • 构造方法的定义格式和作用：
    • 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
    • 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 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()
2.6 super和this

父类空间优先于子类对象产生:

  • 在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。
    在这里插入图片描述

super和this的含义：

  • super：代表父类的存储空间标识(可以理解为父类的引用)。
  • this：代表当前对象的引用(谁调用就代表谁)。

super和this的用法:

  • 访问成员

    this.成员变量 ‐‐ 本类的 
super.成员变量 ‐‐ 父类的 
this.成员方法名() ‐‐ 本类的 
super.成员方法名() ‐‐ 父类的

  • 用法演示

    class Animal {
    public void eat() {
        System.out.println("animal:eat");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("cat:eat");
    }

    public void eatTest() {
        this.eat(); //this 调用本类的方法
        super.eat(); //super 调用父类的方法
    }
}

public class ExtendsDemo08 {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Cat c = new Cat();
        c.eatTest();
    }
}
//结果
animal:eat
cat:eat
animal:eat

  • 访问构造方法

    this(...) ‐‐ 本类的构造方法 
super(...) ‐‐ 父类的构造方法

    子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

2.7 继承的特点

  • Java只支持单继承，不支持多继承。

    //一个类只能有一个父类，不可以有多个父类。 
class C extends A{} //ok 
class C extends A，B... //error

  • Java支持多层继承(继承体系)。

    class A{} 
class B extends A{} 
class C extends B{}

    顶层父类是Object类。所有的类默认继承Object，作为父类。

  • 子类和父类是一种相对的概念。

三、多态

3.1 概述

多态是继封装、继承之后，面向对象的第三大特性。
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也 是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

定义：

  • 多态： 是指同一行为，具有多个不同表现形式。

前提：

  • 继承或者实现【二选一】。
  • 方法的重写【意义体现：不重写，无意义】 。
  • 父类引用指向子类对象【格式体现】。
3.2 多态的体现

  • 多态体现的格式：

    父类类型 变量名 = new 子类对象; 
变量名.方法名();

    父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

    Fu f = new Zi(); f.method();

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

    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) { 
		//多态形式，创建对象 
		Animal a1 = new Cat(); 
		//调用的是Cat的eat 
		a1.eat(); 
		//多态形式，创建对象 
		Animal a2 = new Dog(); 
		//调用的是Dog的eat 
		a2.eat(); 
	} 
}
//结果
吃鱼
吃骨头
3.3 多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展 性与便利。

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都可以完成。
  • 所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
3.4 引用类型转换

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

  • 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

  • 当父类引用指向一个子类对象时，便是向上转型。

  • 使用格式：

    父类类型 变量名 = new 子类类型(); 
如：Animal a = new Cat();

向下转型:

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

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

  • 使用格式：

    子类类型 变量名 = (子类类型) 父类变量名; 
如:Cat c =(Cat) a;

为什么要转型:

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

  • 转型演示:

    abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    @Override
    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 static void main(String[] args) {
    //向上转型
    Animal a = new Cat();
    a.eat();//调用的是Cat的eat
    //向下转型
    Dog d = (Dog)a;
    d.watchHouse(); //调用的是Dog的watchHouse 【运行报错】
}

在这里插入图片描述

  • 这段代码可以通过编译，但是运行时，却报出了 ClassCastException，类型转换异常！这是因为，明明创建了 Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

  • 为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验。

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

  • 所以，转换前，我们最好先做一个判断：

    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
    }
}
//结果
吃鱼
抓老鼠
残*影
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java封装继承多态实例以及文件流操作
04-15
在这个实例中，我们将探讨四个关键概念：封装、继承、多态以及文件流操作，这些都是Java中的核心特性，也是理解OOP（面向对象编程）的基础。 首先，**封装**是面向对象编程的核心理念之一，它涉及将数据和方法捆绑...
Java封装、继承、多态三大特征的理解
08-27
Java封装、继承、多态三大特征的理解 Java语言中的三大特征分别是封装、继承和多态，这三大特征是面向对象编程的核心概念，掌握这些特征是 Java 开发者必须具备的基本技能。 封装 封装是指隐藏对象的属性和实现...
Java学习每日总结四
qq_46042081的博客
12-18 154
大学自学Java（四） 学习的第四天，会分享学习中有意思值得深挖的部分或难点 继承 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可。 就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。 格式 class 父类 { ... } class...
Java学习笔记⑧（继承、抽象、发红包案例）
weixin_45994391的博客
10-04 146
一、继承 继承的格式： 在继承的关系中，“子类就是一个父类”也就是说，子类可以被当做父类看待。例如父类是员工，子类是讲师，那么“讲师就是一个员工”。 定义父类的格式：(一个普通的类定义） public class 父类名称 { //… } 定义子类的格式： public class 子类名称 extends 父类名称 { //… } package cn.itcast.day09.demo01; public class Demo0lExtends { public static vo
11.26 抽象类 this
weixin_30647065的博客
11-26 315
抽象类　　关键字 abstract 1、抽象类继承子类里面会有明确的方法重写要求，而普通类没有。 2、抽象类之比普通类多了一些抽象方法的定义,其他组成部分与普通类完全一样。 3、普通类对象可以直接实例化，但是抽象类的对象必须向上转型之后才可以实例化（运用到多态性）。 abstract class A { // 定义一个抽象类，使用abstract声明 ...
java 抽象类 this_【Java_08】继承、super与this、抽象类
weixin_35240068的博客
03-05 158
一、继承1. 继承的介绍① 多个类中有相同的属性和行为，将这些单独抽取到一个单独的类中，然后再继承这个类即可，无需再定义这些属性和行为。② 继承就是子类继承父类的非私有的属性和方法。③ 好处* 提高了代码的复用性* 继承是多态的前提2. 继承的使用① 格式public class 父类 { ··· }public class 子类 extends 父类 { ··· }② 成员变量* 不重名没有影响...
day10【继承、super、this、抽象类】
qq_38664094的博客
01-09 144
1.继承 1.1继承概念 1.2继承的格式 class 父类 { … } class 子类 extends 父类 { … } */ class Employee { String name; // 定义name属性 // 定义员工的工作方法 public void work() { System.out.println("尽心尽力地工作"); } } /* * 定义讲师类Teacher 继承...
详解java封装继承多态
08-26
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
Java SE编程入门教程 java封装继承多态（共56页）.pptx
12-04
在Java中，`extends`关键字用于实现继承，多态则通过方法重写和抽象类/接口来实现。 3. **类和对象**：类是对象的蓝图，它定义了对象的属性（变量）和行为（方法）。对象是类的实例，具有类定义的属性和方法。Java...
Java面向对象编程（封装/继承/多态）实例解析
08-29
Java 面向对象编程（封装/继承/多态）实例解析 Java 面向对象编程是一种编程范式，它强调对象之间的交互和继承关系。在 Java 中，面向对象编程主要体现在三大特征：封装、继承和多态。 封装是指隐藏对象的内部细节...
12-继承、super、this、抽象类
wiciked的博客
03-07 151
继承 现实生活中的对象具备共同的特性，例如，教师和学生都是人，都具有人的共性，例如姓名、年龄等，这样，我们就可以先定义人这一类，然后让教师和学生继承人的这些特性，从而可以代码复用 格式 class People { ... } class Teacher extends People { ... } 用extends关键字即可实现继承 注意事项： java中的继承是单继承，也就是说，一个类...
模拟微信红包功能（一）使用“继承-extends ”
助你成为一名优秀的全栈工程师！
06-23 245
发红包案例（掌握Java中的继承） 需求 群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则： 群主的一笔金额，从群主余额中扣除，平均分成n等份，让成员领取。 成员领取红包后，保存到成员余额中。 程序运行结果 代码 package com.junlong.red; /** * 用户类 * @Author: junlong.zhou * @Date: 2021/6/23 16:33 * @Version 1.0 */ public class User { pri
用java实现发红包操作（代码+图+笔记）超详细！！！
fighting_dream的博客
06-09 5196
先来实现用户类 群主来发红包，成员抢红包，那么就涉及群主类和成员类。 群主和成员都有基本变量：称谓和余额 因此，可以把他们相同的地方整合起来，用户类就出现了。 用户类，我们设有基本变量name和money。无参构造函数全参构造函数以及getter and setter我们全都可以用快捷键搞定（前面文章有说到，不懂可以回去查阅哈）。为了很好地显示姓名和余额等情况，我们定义了一个成员方法void； 完整代码如下： package it.cast.demo01.day0609; public class U
java 抽象类 this_可以在java中的抽象类中使用关键字“this”
weixin_26895511的博客
02-12 1361
A)你不能在这个意义上覆盖字段。字段“不是虚拟的”方法。fields cannot be overridden but they can be hidden ie if you declare a field in a subclass with the same name as one in the superclass, the superclass field can only be acc...
java 抽象类 this_java抽象类的使用
weixin_42136791的博客
02-12 845
/*当多个类中出现相同功能，但是功能主体不同，这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。抽象：看不懂。抽象类的特点：1，抽象方法一定在抽象类中。2，抽象方法和抽象类都必须被abstract关键字修饰。3，抽象类不可以用new创建对象。因为调用抽象方法没意义。4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子...
super关键字以及super指的是抽象父类时的情形
qq_42130750的博客
05-10 652
1、当子类需要使用父类的方法（该方法已经被子类重写）时可以使用super.方法（），而当子类重写了父类的变量名时，super就不行了，就无法用子类去访问父类的这个被重写的变量，而只能用父类自己去访问。 2、对于父类是抽象类时，不能用new对其进行实例化，那怎么去使用抽象父类中的非静态方法呢？（因为非静态方法只能用对象去访问，而此时该类是抽象类不能进行new实例化），答案很简单：使用super关键...
C#（十六）之C#类中的成员属性 构造函数 析构函数
camellia的博客
07-01 378
C#中类的成员属性、构造函数、析构函数。 代码是基于昨天类的代码进行测试的。 基本代码： /*声明对象*/ cat Tom = new cat(); Tom.age = -1; //设置年龄 Tom.TalkAge(); //输出：我今年-1岁了 类中的方法： /*我今年几岁了*/ public void TalkAge() { Console.WriteLine("我今年{0}岁...
Java封装继承多态
最新发布
05-25
Java是一种面向对象的编程语言，它支持面向对象编程的三大特性：封装、继承和多态。这三个特性是面向对象编程的基础，它们有助于提高代码的可维护性、可复用性和可扩展性。 封装是一种将数据和行为组合在一起的机制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值