【Java】Java进阶学习笔记（三）—— 面向对象（多态）

news2025/1/18 9:06:17

【Java】Java进阶学习笔记（三）—— 面向对象（多态）

  • 一、多态的概念
    • 1、多态的优点
    • 2、多态存在的三个必要条件
    • 3、多态中的成员特点
    • 4、重写方法的快捷键
  • 二、多态的转型
      • 1、向上转型
      • 2、向下转型
      • 3、代码示例
      • 4、转型的异常
        • 类型转换异常
        • instanceof 比较操作符
      • 5、动态绑定
  • 三、多态实例
    • 1、多态的使用
    • 2、多态数组
    • 3、多态参数
  • 四、多态的实现方式
      • 方式一：重写
      • 方式二：接口
      • 方式三：抽象类和抽象方法

一、多态的概念

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

多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

在这里插入图片描述
多态性是对象多种表现形式的体现。

1、多态的优点

1. 消除类型之间的耦合关系；
2. 可替换性；
3. 可扩充性：定义方法的时候，使用父类类型作为参数，将来使用时，**使用具体的子类类型操作**
4. 接口性；
5. 灵活性：无论右边new的时候换成哪个子类对象，等号左边调用方法都不会变化。
6. 简化性

2、多态存在的三个必要条件

  • 继承：在多态中必须存在有继承或实现关系的子类和父类；

  • 方法的重写：子类对父类中的某些方法进行重新定义（重写，使用@Override注解进行重写）

  • 父类引用指向子类对象：Parent p = new Child();

在这里插入图片描述

class Shape {
    void draw() {}
}
 
class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}
 
class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}
 
class Triangle extends Shape {
    void draw() {
        System.out.println("Triangle.draw()");
    }
}

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

以下是一个多态实例的演示，详细说明请看注释：


public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

执行以上程序，输出结果为：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

3、多态中的成员特点

多态成员方法：编译看左边，运行看右边

此处举例Animal是父类，Dog是子类

Animal  dog  =  new Dog（）；  //Animal是引用类型，Dog是实际类型
dog.eat();     //变量dog的实际类型是Dog,即是由Dog 这个实际类型new出来的，因此dog.eat() 调用的应该是子类Dog中重写的方法

4、重写方法的快捷键

  1. 在子类Dog中右键选择Generate

在这里插入图片描述
2. 选择Override Methods然后点击生成

在这里插入图片描述

二、多态的转型

1、向上转型

  • 本质：
    父类的引用指向子类的对象

  • 特点：

    （1）编译类型看左边，运行类型看右边；
    （2）可以调用父类的所有成员（需遵守访问权限）；
    （3）不能调用子类的特有成员；
    （4）运行效果看子类的具体实现。

  • 语法：

父类类型 引用名 = new 子类类型();

2、向下转型

  • 本质：

一个已经向上转型的子类对象，将父类引用转为子类引用。

  • 特点：

    （1）只能强制转换父类的引用，不能强制转换父类的对象；
    （2）要求父类的引用必须指向的是当前目标类型的对象；
    （3）当向下转型后，可以调用子类类型中所有的成员。

  • 语法：

子类类型 引用名 = (子类类型) 父类引用;
//用强制类型转换的格式，将父类引用类型转为子类引用类型

3、代码示例

说明：

定义一个 Person 类 作为父类，定义 Student 类 和 Teacher 类作为子类继承父类；
Person 类 拥有 mission() 方法；
Student 类 和 Teacher 类 重写父类的 mission() 方法 并且 分别拥有各自的特有的 score() 方法 和 salary() 方法；
最后在 main 函数中 演示转型。

代码如下：

（1）定义类：

package Poly_;

public class Person {
	public void mission() {	
		System.out.println("人要好好活着！");
	}
}

class Student extends Person {	
	@Override
	public void mission() {	
		System.out.println("学生要好好学习！");
	}
	
	public void score() {
		System.out.println("学生得到好成绩！");
	}
}

class Teacher extends Person {
	@Override
	public void mission() {	
		System.out.println("老师要好好教书！");
	}
	
	public void salary() {	
		System.out.println("老师得到高工资！");
	}
}

（2）在 Test02 类中编写 main 函数，演示转型

package Poly_;

//转型演示
public class Test02 {
	public static void main(String[] args) {
		//向上转型（自动类型转换）
		Person p1 = new Student();
		
		//调用的是 Student 的 mission
		p1.mission(); 
		
		//向下转型
		Student s1 = (Student)p1;
		
		//调用的是 Student 的 score
		s1.score();
	}
}

（3）运行结果：

学生要好好学习！
学生得到好成绩！

4、转型的异常

类型转换异常

说明：使用强转时，可能出现异常，对2.3代码示例中的 Test02类 重新编写，演示转型异常。

代码如下：

//异常演示
public class Test02 {
	public static void main(String[] args) {
		//向上转型
		Person p1 = new Student();
		
		//调用的是 Student 的 mission
		p1.mission(); 
		
		//向下转型
		Teacher t1 = (Teacher) p1;
		
		//运行时报错
		p1.salary();
	}
}

解释：这段代码在运行时出现了 ClassCastException 类型转换异常，原因是 Student 类与 Teacher 类 没有继承关系，因此所创建的是Student 类型对象在运行时不能转换成 Teacher 类型对象。

instanceof 比较操作符

为了避免上述类型转换异常的问题，我们引出 instanceof 比较操作符，用于判断对象的类型是否为XX类型或XX类型的子类型。

格式：对象 instanceof 类名称
解释：这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例

代码示例 ：

package Poly_;

//演示 instanceof 的使用
public class Test03 {
	public static void main(String[] args) {
		//向上转型
		Person p1 = new Student();
		
		//调用的是 Student 的 mission
		p1.mission();
		
		//向下转型
		//利用 instanceof 进行判断
		if(p1 instanceof Student) {	//判断对象 p1 是否是 Student 类 的实例
			Student s1 = (Student)p1;
			s1.score();  //调用的是 Student 的 score
			//上面这两句也可简写为 ((Student) p1).score();
		}
		else if(p1 instanceof Teacher){ //判断对象 p1 是否是 Teacher 类 的实例
			Teacher t1 = (Teacher)p1;
			t1.salary(); //调用的是 Teacher 的 salary
			//同理，上面这两句也可简写为 ((Teacher) p1).salary();
		}
	}
}

运行结果：

学生要好好学习！
学生得到好成绩！

5、动态绑定

  • 当调用对象方法的时候，该方法会和该对象的运行类型绑定
  • 当调用对象属性时，没有动态绑定机制，即哪里声明，哪里使用。

代码示例：

package dynamic_;

//演示动态绑定
public class DynamicBinding {
	public static void main(String[] args) {
		//向上转型（自动类型转换）
		//程序在编译阶段只知道 p1 是 Person 类型
		//程序在运行的时候才知道堆中实际的对象是 Student 类型	
		Person p1 = new Student();  
		
		//程序在编译时 p1 被编译器看作 Person 类型
		//因此编译阶段只能调用 Person 类型中定义的方法
		//在编译阶段，p1 引用绑定的是 Person 类型中定义的 mission 方法（静态绑定）
		//程序在运行的时候，堆中的对象实际是一个 Student 类型，而 Student 类已经重写了 mission 方法
		//因此程序在运行阶段对象中绑定的方法是 Student 类中的 mission 方法（动态绑定）
		p1.mission();
	}
}

//父类
class Person {
	public void mission() {	
		System.out.println("人要好好活着！");
	}
}

//子类
class Student extends Person {
	@Override
	public void mission() {	
		System.out.println("学生要好好学习！");
	}
}

三、多态实例

1、多态的使用

/* 文件名 : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number) {
      System.out.println("Employee 构造函数");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck() {
      System.out.println("邮寄支票给： " + this.name
       + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
     return number;
   }
}

假设下面的类继承Employee类：

/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // 全年工资
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck() {
       System.out.println("Salary 类的 mailCheck 方法 ");
       System.out.println("邮寄支票给：" + getName()
       + " ，工资为：" + salary);
   }
   public double getSalary() {
       return salary;
   }
   public void setSalary(double newSalary) {
       if(newSalary >= 0.0) {
          salary = newSalary;
       }
   }
   public double computePay() {
      System.out.println("计算工资，付给：" + getName());
      return salary/52;
   }
}

测试代码

/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
   public static void main(String [] args) {
      Salary s = new Salary("员工 A", "北京", 3, 3600.00);
      Employee e = new Salary("员工 B", "上海", 2, 2400.00);
      System.out.println("使用 Salary 的引用调用 mailCheck -- ");
      s.mailCheck();
      System.out.println("\n使用 Employee 的引用调用 mailCheck--");
      e.mailCheck();
    }
}

以上实例编译运行结果如下：

Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck -- 
Salary 类的 mailCheck 方法 
邮寄支票给：员工 A ，工资为：3600.0

使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法 
邮寄支票给：员工 B ，工资为：2400.0

例子解析

实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。

当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到 mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。

e 是 Employee 的引用，但引用 e 最终运行的是 Salary 类的 mailCheck() 方法。

在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。

以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。

Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。

2、多态数组

多态数组：数组的定义类型为父类类型，里面保存的实际元素类型为子类类型。
代码示例：（循环调用基类对象，访问不同派生类的方法）

说明：

定义一个 Person 类 作为父类，定义 Student 类 和 Teacher 类 作为子类继承父类；
Person 类 拥有 name(姓名) 属性 以及 mission() 方法；
Student 类 和 Teacher 类 拥有各自特有的 score 和 salary 属性,，除此之外，重写父类的 mission() 方法 ；
要求：最后在 main 函数中 创建一个 Person 对象 、一个 Student 对象 和 一个 Teacher 对象，统一放在数组里，并调用每个对象的 mission() 方法。

代码如下：

（1）父类 Person 类：

package polyarr;

public class Person {
	private String name;
	
	public Person(String name) {
		this.name = name;
	}
	
	// getter 和 setter
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	// mission() 方法
	public String mission() {	
		return name + "\t" + "要好好活着";
	}
}

（2）子类 Student 类

package polyarr;

public class Student extends Person {
	private double score;

	public Student(String name, double score) {
		super(name);
		this.score = score;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}
	
	//重写父类的say方法
	@Override
	public String mission() {	
		return super.mission() + " score =" + score + " 要好好学习！";
	}
}

（3）子类 Teacher 类

package polyarr;

public class Teacher extends Person {
	private double salary;

	public Teacher(String name, double salary) {
		super(name);
		this.salary = salary;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	//重写父类的 mission 方法
	@Override
	public String mission() {	
		return super.mission() + " salary =" + salary + " 要好好教书！";
	}
}

（4）PolyArray 类 中编写 main 函数

package polyarr;

/*
 * 演示多态数组
 * 创建一个 Person 对象 
 * 创建一个 Student 对象 
 * 创建一个 Teacher 对象
 * 统一放在数组里，并调用每个对象的 mission() 方法。
 */
public class PolyArray {
	public static void main(String[] args) {
		Person[] persons = new Person[3];
		persons[0] = new Person("小汤");
		persons[1] = new Student("小韬", 100);
		persons[2] = new Teacher("小蒲", 10000);
		
		//循环遍历多态数组，调用 mission
		for(int i = 0; i < persons.length; i++) {
			//此处涉及动态绑定机制
			// Person[i] 编译类型是 Person ,运行类型根据实际情况由 JVM 判断
			System.out.println(persons[i].mission());  
		}
	}
}

（5）运行结果：

小汤	要好好活着！
小韬	要好好活着！ score = 100.0 要好好学习！
小蒲	要好好活着！ salary = 10000.0 要好好教书！

3、多态参数

多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型。
代码示例：

说明：

定义一个 Person 类 作为父类，定义 Student 类 和 Teacher 类作为子类继承父类；
Person 类 拥有 name(姓名) 属性
Student 类 和 Teacher 类 拥有各自 特有 的 study() 和 teach() 方法 ；
要求：最后在 main 函数中 编写 test() 方法 ，功能是调用 Student 类 的 study() 或 Teacher 类 的 teach() 方法，用于演示 多态参数 的使用。

代码如下：

package polyparameter;

//演示多态参数
public class PolyParameter { 
	public static void main(String[] args) {
		Student s1 = new Student("小蓝同学");
		Teacher t1 = new Teacher("小绿老师");
		
		//需先 new 一个当前类的实例化，才能调用 test 方法
		PolyParameter polyParameter = new PolyParameter();
		
		//实参是子类
		polyParameter.test(s1);
		polyParameter.test(t1);		
	}

	//定义方法test，形参为 Person 类型(形参是父类)
	//功能：调用学生的study或教师的teach方法
	 public void test(Person p) {
        if (p instanceof Student){
            ((Student) p).study();   //向下转型
        }
        else if (p instanceof Teacher){
            ((Teacher) p).teach();  //向下转型
        }  
	 }
}
 
//父类
class Person {
	private String name;
	
	//有参构造
	public Person(String name) {
		this.name = name;
	}
	
	// getter 和 setter
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

//子类
class Student extends Person {

	public Student(String name) {
		super(name);
	}

	// study() 方法
	public void study() {	
		System.out.println(super.getName() + "\t" + "正在好好学习");
	}
}

class Teacher extends Person {

	public Teacher(String name) {
		super(name);
	}

	// teach() 方法
	public void teach() {	
		System.out.println(super.getName() + "\t" + "正在好好教书");
	}
}

运行结果：

小蓝同学	正在好好学习
小绿老师	正在好好教书

四、多态的实现方式

方式一：重写

这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。

方式二：接口

1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。

2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。

方式三：抽象类和抽象方法

参考博客：
https://blog.csdn.net/z972065491/article/details/127220556

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/378613.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

无线蓝牙耳机哪个品牌延迟低？玩游戏延迟低的蓝牙耳机推荐

无线蓝牙耳机哪个品牌延迟低？玩游戏延迟低的蓝牙耳机推荐

无线蓝牙耳机因为摆脱了线的束缚&#xff0c;在使用上会更便捷&#xff0c;不少人喜欢戴蓝牙耳机玩游戏&#xff0c;但又怕蓝牙耳机有延迟。正因为蓝牙耳机摆脱了线的束缚&#xff0c;在信号传输的过程中难免产生延迟。那么&#xff0c;无线蓝牙耳机哪个品牌延迟低&#xff1f;…
阅读更多...
【Linux】程序员的易筋经——冯诺依曼体系结构

【Linux】程序员的易筋经——冯诺依曼体系结构

文章目录&#x1f449;冯诺伊曼体系结构&#x1f448;概念内存的重要性&#x1f449;操作系统&#xff08;Operating System&#xff09;&#x1f448;概念目的定位特征发展和分类运行机制体系结构&#x1f449;冯诺伊曼体系结构&#x1f448; 概念 下图是描述冯诺依曼体系结…
阅读更多...
6天重建一遍中国台湾省，三维模型还可以这样做！

6天重建一遍中国台湾省，三维模型还可以这样做！

说起三维模型&#xff0c;大家脑海中显现的大多是一个可通过电子屏幕进行全方位展示的立体物体。一般来说&#xff0c;所显示的物体既可以是现实世界的实体&#xff0c;也可以是通过想象所创作的虚构物体。 而实景三维正是镜像作用于现实世界真实化表达的新兴技术&#xff0c;是…
阅读更多...
Java中的过滤器和拦截器

Java中的过滤器和拦截器

Java中的过滤器和拦截器 一.应用场景 拦截器应用场景 拦截器本质上是面向切面编程&#xff08;AOP&#xff09;&#xff0c;符合横切关注点的功能都可以放在拦截器中来实现&#xff0c;主要的应用场景包括&#xff1a; 登录验证&#xff0c;判断用户是否登录。权限验证&…
阅读更多...
JSP的分页

JSP的分页

分页在读取数据库里的数据需要用&#xff0c;在以后数据库肯定还会有很多数据&#xff0c;一个页面装不下&#xff0c;所以需要分页功能。数据库查询的分页语句是“SELECT * FROM emp LIMIT 0, 5;”这里0是指起始行&#xff0c;5是查询5行&#xff0c;第二页起始行就是5&#x…
阅读更多...
QT 实现右键菜单

QT 实现右键菜单

有时我们希望在窗口中右键弹出菜单&#xff0c;这里来介绍一下QT中怎么实现. .h 中添加事件相应函数声明和变量定义&#xff1a; private:// 菜单事件void contextMenuEvent(QContextMenuEvent* event) override;void initMenu();private:QMenu* m_pMenu nullptr;在构造函数中…
阅读更多...
聊聊如何避免多个jar通过maven打包成一个jar，多个同名配置文件发生覆盖问题

聊聊如何避免多个jar通过maven打包成一个jar，多个同名配置文件发生覆盖问题

前言 不知道大家在开发的过程中&#xff0c;有没有遇到这种场景&#xff0c;外部的项目想访问内部nexus私仓的jar&#xff0c;因为私仓不对外开放&#xff0c;导致外部的项目没法下载到私仓的jar&#xff0c;导致项目因缺少jar而无法运行。 通常遇到这种场景&#xff0c;常用…
阅读更多...
HUN工训中心：开关电路和按键信号抖动

HUN工训中心：开关电路和按键信号抖动

工训中心的牛马实验 1.实验目的&#xff1a; 1) 认识开关电路&#xff0c;掌握按键状态判别、开关电路中逻辑电平测量、逻辑值和逻辑函数电路。 2) 掌握按键信号抖动简单处理方法。 3) 实现按键计数电路。 2.实验资源&#xff1a; HBE硬件基础电路实验箱、示波器、万用表…
阅读更多...
Java学习--网络编程

Java学习--网络编程

1. 网络编程入门 1.1 网络编程概述 计算机网络 是指将地理位置不同的具有独立功能的多台计算机及其外部设备&#xff0c;通过通信线路连接起来&#xff0c;在网络操作系统&#xff0c;网络管理软件及网络通信协议的管理和协调下&#xff0c;实现资源共享和信息传递的计算机系统…
阅读更多...
【GIT】git不同仓库设置不同用户名和邮箱

【GIT】git不同仓库设置不同用户名和邮箱

随着业务的拓展&#xff0c;工作中&#xff0c;我们除了要在公司的git库提交代码&#xff0c;还可能在阿里云效codeup、gitcode等上提交代码。 之前git安装时使用的是全局名称&#xff0c;导致所有的git提交都使用了相同的用户名和邮箱。 查看全局用户名和邮箱 $ git config -…
阅读更多...
论文调研——23.2.28

论文调研——23.2.28

文章目录Diffusion Models: A Comprehensive Survey of Methods and ApplicationsADVERSARIAL TRAINING METHODS FOR SEMI-SUPERVISED TEXT CLASSIFICATIONHuman Emotion Knowledge Representation Emerges in LargeAPI 调优上&#xff1a; Decoder Tuning: Efficient Language…
阅读更多...
记录一下atlas200模块无法正常通过别的设备SSH连接192.168.1.2问题笔记粗心者用

记录一下atlas200模块无法正常通过别的设备SSH连接192.168.1.2问题笔记粗心者用

atlas200远程登录发现登录不了 串口打印内核信息正常显示&#xff0c;如下几个错误记录分别在windows上和ubuntu上分别做了测试&#xff0c;之前都是 安装完 kex_exchange_identification: read: Connection reset 华为atlas200模块 登录显示这个目前没有解决&#xff0c;应该…
阅读更多...
220V转5V非隔离2W电源--超低成本

220V转5V非隔离2W电源--超低成本

目录 详情 产品特性和优势 设计电路 MP150芯片资料 详情 MP150 是一款原边调节器&#xff0c;可以在无光耦合器的条件下提供精确的恒压&#xff08;CV&#xff09;调节。MP150 支持降压、升降压、升压和反激拓扑。它内部集成了 500V MOSFET&#xff0c;可简化结构&#xff0…
阅读更多...
HUN工训中心：三位数码管扫描显示实验报告

HUN工训中心：三位数码管扫描显示实验报告

工训中心牛马实验 1.1操作说明及现象描述 根据老师发的安装包下载和安装好Quartus II软件。在电脑安装USB硬件驱动&#xff0c;再与PC接口连接好&#xff0c;可以打开任务管理器查看是否安装好。之后打开Quartus II软件&#xff0c;按照菜单Tool->programmer->add file…
阅读更多...
6大类，不同类型单板布线策略

6大类，不同类型单板布线策略

PCB布线策略 一、类型一主要特征如下 严格的长度规则、严格的串扰规则、拓扑规则、差分规则、电源地规则等。 二、关键网络的处理&#xff1a;总线定义Class 要求满足一定的拓扑结构、stub及其长度(时域)约束条件 图-1 平衡菊花链和中间驱动菊花链图 设置虚拟管脚来控制拓扑…
阅读更多...
张驰咨询：六西格玛常见问题解答

张驰咨询：六西格玛常见问题解答

以下是张驰咨询对一些关于六西格玛常见问题的解答&#xff1a; 1、六西格玛是什么&#xff1f; 六西格玛是一种改善企业质量流程管理的技术&#xff0c;以“零缺陷”的完美商业追求&#xff0c;带动质量大幅提高、成本大幅度降低&#xff0c;最终实现企业财务成效的提升与企业…
阅读更多...
SpringCloud系列知识快速复习 -- part 1（SpringCloud基础知识，Docker，RabbitMQ）

SpringCloud系列知识快速复习 -- part 1（SpringCloud基础知识，Docker，RabbitMQ）

SpringCloud知识快速复习SpringCloud基础知识微服务特点SpringCloud常用组件服务拆分和提供者与消费者概念Eureka注册中心原理Ribbon负载均衡原理负载均衡策略饥饿加载Nacos注册中心服务分级存储模型权重配置环境隔离Nacos与Eureka的区别Nacos配置管理拉取配置流程配置热更新配…
阅读更多...
大家挤破脑袋都想进的腾讯，你为什么想要辞职？

大家挤破脑袋都想进的腾讯，你为什么想要辞职？

前几天&#xff0c;我在网上看到一个故事。 故事的主人翁是19届的校招生&#xff0c;目前入职腾讯&#xff0c;工作了一个月。这一个月给他的感受是大量的写测试用例&#xff0c;感觉自己写测试用例的能力熟练了不少&#xff0c;测试技能倒是没有多大的提高&#xff0c;真正需…
阅读更多...
一文解决Python所有报错

一文解决Python所有报错

前言 Python是一种强大的编程语言&#xff0c;但是它也有一些报错&#xff0c;这些报错可能会让你感到困惑。本文将介绍如何解决Python中的常见报错。 首先&#xff0c;让我们来看看Python中最常见的报错&#xff1a;SyntaxError。这种报错表明你的代码中有语法错误&#xff0c…
阅读更多...
Javaweb增删改查之【查】

Javaweb增删改查之【查】

Javaweb增删改查之【查】1.前端页面2.java链接数据库——集成mybatis2.1 建立层2.2 实体层entity2.3 mapper&#xff08;dao层&#xff09;2.4 mybatis配置文件2.5工具层util3.后台功能3.1servlet前几天跟着b站up主学javaweb登录&#xff0c;突然还是觉得这几年学了c是真的挺好…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023