1.Java设计模式（设计模式前置知识：七大原则）

已于 2022-10-11 09:35:57 修改
阅读量165 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式 开发语言
于 2022-10-09 12:29:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G_change_/article/details/127224379
版权

1.Java设计模式

一.内容介绍

​ 设计模式是对软件设计中普遍存在的各种问题，所提出的解决方案。

二.七大原则

1.单一职责原则

​ 对类来说，即一个类应该只负责一项职责。比如userDao只负责用户的职责。把一个类拆为多个类。

​ 作用：1.降低类的复杂度，一个类只负责一项职责

​ 2.提高类的可读性，可维护性

​ 3.降低变更引起的风险、

​ 4.在通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以违反；只有类中方法数量足够少，可以在方法级别保持单一原则。

案例：

package singleresponsibility;

public class Singleresponsibility {
	public static void main(String[] args) {
		Vehicle vehicle = new Vehicle();
		vehicle.run("摩托车");
		vehicle.run("汽车");
		vehicle.run("飞机");
	}
}

//交通工具类
//飞机不是在公路上跑，所以违反单一职责原则
//解决：根据交通方式的不同，分解成不同的类
class Vehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "在公路上跑");
	}
}

单一职责优化案例：

package singleresponsibility;

public class Singleresponsibility2 {
	public static void main(String[] args) {
		RoadVehicle roadVehicle = new RoadVehicle();
		roadVehicle.run("摩托");
		
		AirVehicle airVehicle = new AirVehicle();
		airVehicle.run("飞机");
		
		WaterVehicle waterVehicle = new WaterVehicle();
		waterVehicle.run("轮船");
	}
}

//这种方案开销大
class RoadVehicle{
	public void run(String vehicle) {
		System.out.println(vehicle+"在公路上运行");
	}
}
class AirVehicle{
	public void run(String vehicle) {
		System.out.println(vehicle+"在天空上运行");
	}
}
class WaterVehicle{
	public void run(String vehicle) {
		System.out.println(vehicle+"在水里运行");
	}
}


package singleresponsibility;

public class Singleresponsibility3 {
	public static void main(String[] args) {
		Vehicle2 vehicle2 = new Vehicle2();
		vehicle2.run("汽车");
		vehicle2.runAir("飞机");
		vehicle2.runWater("船");
	}
}

class Vehicle2 {
	public void run(String vehicle) {
		System.out.println(vehicle + "在公路上跑");
	}
	
	public void runAir(String vehicle) {
		System.out.println(vehicle + "在天空上运行");
	}
	
	public void runWater(String vehicle) {
		System.out.println(vehicle + "在水中运行");
	}
}
2.接口隔离原则

​ 客户端不应该依赖它不需要的接口，及一个类对另一个类的依赖应该建立在最小的接口上。

​ 接口隔离原则：一个类对另一个类的依赖应该建立在最小的接口上

package segregation2;

import org.junit.Test;

public class Segregation1 {
	public static void main(String[] args) {
		A a = new A();
		a.depend1(new B());//A类通过接口依赖B类
		a.depend2(new B());
		a.depend3(new B());
		
		C c = new C();
		c.depend1(new D());
		c.depend4(new D());
		c.depend5(new D());
	}
}

interface Interface1{
	void opertion1();
}
interface Interface2{
	void opertion2();
	void opertion3();
}
interface Interface3{
	void opertion4();
	void opertion5();
}

class B implements Interface1,Interface2{

	@Override
	public void opertion1() {
		// TODO Auto-generated method stub
		System.out.println("B实现了opertion1");
	}

	@Override
	public void opertion2() {
		// TODO Auto-generated method stub
		System.out.println("B实现了opertion2");
	}

	@Override
	public void opertion3() {
		// TODO Auto-generated method stub
		System.out.println("B实现了opertion3");
	}	
}

class D implements Interface1,Interface3{

	@Override
	public void opertion1() {
		// TODO Auto-generated method stub
		System.out.println("D实现了opertion1");
	}


	@Override
	public void opertion4() {
		// TODO Auto-generated method stub
		System.out.println("D实现了opertion4");
	}

	@Override
	public void opertion5() {
		// TODO Auto-generated method stub
		System.out.println("D实现了opertion5");
	}
}

class A{// A类通过接口Interface1依赖（使用）B类，但是只会用到1，2，3方法
	
	public void depend1(Interface1 i) {
		i.opertion1();
	}
	public void depend2(Interface2 i) {
		i.opertion2();
	}
	public void depend3(Interface2 i) {
		i.opertion3();
	}
}

class C{// C类通过接口Interface1依赖（使用）B类，但是只会用到1，4，5方法
	public void depend1(Interface1 i) {
		i.opertion1();
	}
	public void depend4(Interface3 i) {
		i.opertion4();
	}
	public void depend5(Interface3 i) {
		i.opertion5();
	}
}
3.依赖倒转原则

​ 1.高层模块不要依赖底层模块，二者都应该依赖其抽象(接口或者抽象类)

​ 2.抽象不应该依赖细节，细节应该依赖抽象

​ 3.依赖倒转的中心思想是面向接口编程

​ 4.抽象的东西要稳定

package inversion;

public class DependecyInversion {
	public static void main(String[] args) {
		Person person = new Person();
		person.receive(new Email());
		person.receive(new WeinXin());
	}
}

//定义接口
interface IReceiver{
	public String getInfo();
}

class Email implements IReceiver{
	public String getInfo() {
		return "电子邮件信息:helloworld";
	}
}

class WeinXin implements IReceiver{

	@Override
	public String getInfo() {
		// TODO Auto-generated method stub
		return "微新信息:helloJava";
	}
	
}

//完成person接受消息的功能
class Person{
	public void receive(IReceiver receiver) {
		System.out.println(receiver.getInfo());
	}
}
补充：依赖关系传递的三种方式：
1.接口传递依赖
//方式1：通过接口传递实现依赖
//开关的接口
interface ITV{//ITV接口
    public void play();
}
interface IOpenAndClose{//抽象方法接收接口
    public void open(ITV tv);
}
//实现接口
class OpenAndClose implements IOpenAndClose{
    public void open(ITV tv) {
        tv.play();
    }
}

接口传递依赖案例实现

public class DependencyTransmit {
    public static void main(String[] args) {
        ChangHong changHong = new ChangHong();
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.open(changHong);//此处changHong实现了ITV接口所以能够被接收
    }
}
interface ITV{//ITV接口
    public void play();
}
interface IOpenAndClose{//抽象方法接收接口
    public void open(ITV tv);
}
class ChangHong implements ITV{

    public void play() {
        System.out.println("长虹电视打开了...");
    }
}
class OpenAndClose implements IOpenAndClose{
    public void open(ITV tv) {
        tv.play();
    }
}
2.构造方法传递
//方式2：通过构造器口传递实现依赖
interface ITV{//ITV接口
    public void play();
}
interface IOpenAndClose{//抽象方法接收接口
    public void open();
}
//实现接口
class OpenAndClose implements IOpenAndClose{
    private ITV tv;//成员

    public OpenAndClose(ITV tv) {//通过构造器传递依赖
        this.tv = tv;
    }
    public void open() {
       this.tv.play();
    }
}

构造方法传递依赖案例实现

public class DependencyTransmit {
    public static void main(String[] args) {
        ChangHong changHong = new ChangHong();
        OpenAndClose openAndClose = new OpenAndClose(changHong);
        openAndClose.open();
    }
}
//方式2：通过构造器口传递实现依赖
interface ITV{//ITV接口
    public void play();
}
interface IOpenAndClose{//抽象方法接收接口
    public void open();
}
class ChangHong implements ITV{
    public void play() {
        System.out.println("长虹电视打开了...");
    }
}
//实现接口
class OpenAndClose implements IOpenAndClose{
    private ITV tv;//成员

    public OpenAndClose(ITV tv) {//通过构造器传递依赖
        this.tv = tv;
    }
    public void open() {
       this.tv.play();
    }
}
3.setter方式传递
interface ITV{//ITV接口
    public void play();
}
interface IOpenAndClose{
    public void open();
    public void set(ITV tv);//set方法传递接口
}
//实现接口
class OpenAndClose implements IOpenAndClose {
    private ITV tv;
    public void set(ITV tv) {
        this.tv = tv;
    }
    public void open() {
        tv.play();
    }
}

setter方式传递依赖实现

public class DependencyTransmit {
    public static void main(String[] args) {
        ChangHong changHong = new ChangHong();
        //通过setter方法进行依赖传递
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.set(changHong);
        openAndClose.open();
    }
}
interface ITV{//ITV接口
    public void play();
}
interface IOpenAndClose{//抽象方法接收接口
    public void open();
    public void set(ITV tv);
}
class ChangHong implements ITV{
    public void play() {
        System.out.println("长虹电视打开了...");
    }
}
//实现接口
class OpenAndClose implements IOpenAndClose {
    private ITV tv;
    public void set(ITV tv) {
        this.tv = tv;
    }
    public void open() {
        tv.play();
    }
}
4.里氏替换原则

​ 1.引用基类的地方必须能够透明地使用其子类的对象。

​ 2.在使用继承时，遵循里氏替换原则，在子类中尽量不要重新写父类的方法

​ 3.里氏替换原则告诉我们，继承实际上让两个类耦合性增强类。在适当情况下，可以通过聚合，组合，依赖来解决问题。

问题展示：

public class Liskov {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3="+a.func1(11,3));

        System.out.println("------------------");
        B b = new B();
        System.out.println("11-3="+b.func1(11,3));//此处本意是输出11-3结果调用被重写的11+3
        System.out.println("11+3+9="+b.func2(11,3));
    }
}
class A{
    //返回两个数的差
    public int func1(int num1,int num2){
        return num1 - num2;
    }
}
class B extends A{
    @Override
    public int func1(int a, int b) {
        return a+b;
    }
    public int func2(int a, int b) {
        return func1(a,b)+9;
    }
}

使用里氏替换原则

public class Liskov {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3="+a.func1(11,3));
        System.out.println("------------------");
        B b = new B();
        //因为B类不再继承A类因此调用者不会再用func1是求减法
        System.out.println("11-3="+b.func3(11,3));//这里本意是求出11-3
        System.out.println("11+3+9="+b.func2(11,3));
    }
}
class Base{//提供一个更加基础的基类
}
class A extends Base{
    public int func1(int num1,int num2){//返回两个数的差
        return num1 - num2;
    }
}
class B extends Base{
    //如果B需要使用A类的方法，使用组合的关系
    private A a = new A();
    public int func1(int a, int b) {
        return a+b;
    }
    public int func2(int a, int b) {
        return func1(a,b)+9;
    }
    public int func3(int a, int b) {
        return this.a.func1(a,b);
    }
}
5.开闭原则（核心）

​ 1.模块和函数应该对扩展开放（对提供方），对修改关闭（对使用方）;用抽象构建框架，用实现扩展细节。

​ 2.当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

package ocp;

public class Ocp {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		GraphicEditor graphicEditor = new GraphicEditor();
		graphicEditor.drawShape(new Rectangle());
		graphicEditor.drawShape(new Circle());
		graphicEditor.drawShape(new Triangle());
	}

}
//一个用于绘图的类
class GraphicEditor{
	public void drawShape(Shape s) {
		if(s.m_type==1) 
			drawRectangle(s);
		else if(s.m_type==2)
			drawCircle(s);
		else if(s.m_type==3)
			drawTriangle(s);
	}
	public void drawRectangle(Shape r) {
		System.out.println("矩形");
	}
	public void drawCircle(Shape r) {
		System.out.println("圆形");
	}
    //此处新增时，对使用方也进行了修改，违背了OCP原则
	public void drawTriangle(Shape r) {
		System.out.println("三角形");
	}
}
class Shape{
	int m_type;
}
class Rectangle extends Shape{
	 Rectangle() {
		super.m_type=1;
	}
}
class Circle extends Shape{
	 Circle() {
		super.m_type=2;
	}
}
class Triangle extends Shape{
	Triangle() {
		super.m_type=3;
	}
}

利用开闭原则后

package ocp.improve;

public class Ocp {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		GraphicEditor graphicEditor = new GraphicEditor();
		graphicEditor.drawShape(new Rectangle());
		graphicEditor.drawShape(new Circle());
		graphicEditor.drawShape(new Triangle());
		graphicEditor.drawShape(new OtherGraphic());
	}
}

//一个用于绘图的类
class GraphicEditor{
	public void drawShape(Shape s) {
		s.draw();
	}
}
abstract class Shape{
	int m_type;
	public abstract void draw();//抽象方法
}
class Rectangle extends Shape{
	 Rectangle() {
		super.m_type=1;
	}
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("绘制矩形");
	}
}
class Circle extends Shape{
	 Circle() {
		super.m_type=2;
	}
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("绘制圆形");
	}
}
class Triangle extends Shape{
	Triangle() {
		super.m_type=3;
	}
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("绘制三角形");
	}
}

//新增一个其它图形
class OtherGraphic extends Shape{
	OtherGraphic(){
		super.m_type=4;
	}
	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("绘制其它图形");
	}
}
6.迪米特原则

​ 1.一个类应该对其它对象保持最少的了解

​ 2.类与类关系越密切，耦合度越大

​ 3.迪米特法则又称为最少知道原则，即一个类对自己依赖的类知道的越少越好，也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部，对外除了提供的public方法，不对外泄露任何信息。

​ 4.只与直接的朋友通信（每个对象都会与其它对象有耦合关系，只有两个对象之间有耦合关系，那么这两个对象之间是朋友关系，耦合的方式有依赖，关联，组合，聚合等）；成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接朋友，也就是说陌生的类最好不要以局部变量的形式出现在类的内部。

注意事项

​ 1.迪米特法则的核心是降低类之间的耦合

​ 2.每个类都减少了不必要的依赖，因此迪米特法则只是降低类之间(对象间)耦合关系，并不是完全没有依赖关系

未改进代码

public class Demeter1 {//客户端
    public static void main(String[] args) {
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}
//学校总部员工类
class Employee {
    private String id;
    public void setId(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
}
//学院的员工类
class CollegeEmployee {
    private String id;
    public void setId(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
}
//管理学院员工的管理类
class CollegeManager {
    //返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }
}
//学院员工的管理类
class SchoolManager {
    //返回学校总部的员工
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();

        for (int i = 0; i < 5; i++) { //这里我们增加了5个员工到 list
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }
    //该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub) {
        //获取到学院员工
        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println("------------分公司员工----------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
        //获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}

改进代码

public class Demeter1 {//客户端
    public static void main(String[] args) {
        System.out.println("~~~使用迪米特法则的改进~~~");
        SchoolManager schoolManager = new SchoolManager();
        schoolManager.printAllEmployee(new CollegeManager());
    }
}
//学校总部员工类
class Employee {
    private String id;
    public void setId(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
}
//学院的员工类
class CollegeEmployee {
    private String id;
    public void setId(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
}
//管理学院员工的管理类
class CollegeManager {
    //返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }
    //输出学院员工信息
    public void printEmployee(){
        List<CollegeEmployee> list1 = this.getAllEmployee();
        System.out.println("------------分公司员工----------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
    }
}
//学院员工的管理类
class SchoolManager {
    //返回学校总部的员工
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();

        for (int i = 0; i < 5; i++) { //这里我们增加了5个员工到 list
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }
    //该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub) {
        //分析问题
        //1.这里的CollegeEmployee不是SchoolManager的直接朋友
        //2.CollegeEmployee 是以局部变量方式出现再SchoolManager
        //3.违反了迪米特原则
        //将输出学院员工方法，封装到CollegeManager中
        sub.printEmployee();
        //获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}
7.合成复用原则

​ 原则是尽量使用合成/聚合（详细解释查看下一节UML类图讲解）的方式，而不是使用继承

中心思想

​ 1.找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起

​ 2.针对接口编程，而不是针对实现编程

​ 3.为了交互对象之间的松耦合设计而努力

参考资料：B站up 尚硅谷

B0码码码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA的23种设计模式---前置：6大基本原则
Ingram的博客
05-17 3132
概要：该文章参考了《设计模式之禅》一书、百度百科及一些前辈的博客文章 1.该文章阐述了JAVA的6大基本原则； 2.该文章适合初学设计模式的技术人员研习； 3.该文章有许多不足之处，请各位大咖指正，喷子绕道；
体验Java1.5中面向(AOP)编程共11页.pdf.z
10-31
面向切面编程（Aspect-Oriented Programming，AOP）是软件开发中的一种设计模式，它旨在提高代码的可重用性、模块化和可维护性。在Java 1.5中，Spring框架引入了对AOP的支持，使得开发者能够更好地处理系统中的横切...
2.Java设计模式（前置知识-UML类图）
G_change_的博客
10-09 253
设计模式前置知识UML类图
Java设计模式之简介篇
m0_48921244的博客
07-21 195
1、1995年，由Erich Gamma、Richard Helm、Ralph Johnson、John Vlissides合著《设计模式》一书。这四人又被称为“四人组”（Gang of Four），GOF就是这么来的..... 2、设计模式的出现是为了解决具体的某一类问题，解决一些具有共性的问题，而不是针对某个问题而出现的；设计模式是和具体语言无关的；设计模式讲述的是思想，并灵活的巧妙的应用到了具体的实际案例中...... 3、设计模式根据目的来分，分为创建型模式、结构型模式、行为型模式......
【零】Java设计模式[前置] - 设计模式七大原则
Genmer的博客
08-15 197
文章目录前言一、前置知识点1.1 bean的作用范围(就讲讲有分歧的两个，具体查看参考资料)1.1.1 singleton1.1.2 prototype1.1.3 五种作用域（参考资料截图）1.2 scope为protype的bean，spring容器到底管不管1.3 单例Bean和单例模式二、 设计模式七大原则2.1 单一职责原则（保证类的功能统一，减少耦合）2.2 接口隔离原则（保证接口定义精确，减少耦合）2.3 依赖（倒转）倒置原则（面向接口编程）2.4 里氏替换原则（如何正确使用继承）2.5
java设计模式知识总结（23种）
qq_48125562的博客
04-21 2608
设计模式复习总结
Java面试之七大设计原则与设计模式
y516369的博客
10-23 592
Java面试之设计原则与设计模式
Java设计模式七大原则
杨春建的博客
07-25 504
原文地址：http://blog.csdn.net/u011288271/article/details/52497602 对于Java看到过一个很有意思的说法：Java有六大心法，23种武功招式。 分别就是Java设计模式六大原则和常用的23种设计模式了。 本篇是对六大原则的整理。（最后一种是哈姆雷特） 1.开闭原则（Open Close Principle） 定义：一
java 设计模式七大设计原则
qq_34287953的博客
09-14 792
一.开闭原则（Open Close Principle） 定义：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。 作用：保证以前代码的准确性，使开发者更专注于新扩展的代码上。 开放-封闭原则的意思就是说，你设计的时候，时刻要考虑，尽量让这个类是足够好，写好了就不要去修改了，如果新需求来，我们增加一些类就完事了，原来的代码能不动则不动。这个原则有两个特性，一个是...
Java设计模式--------面向对象七大设计原则
weixin_58419099的博客
11-08 1166
​ 面向对象设计原则一共有七个：开闭原则、里氏替换原则、依赖倒转原则、单一职责原则、接口隔离原则、组合/聚合复用原则、迪米特法则。举出了大量的实例 ​
【设计模式】设计模式的七大原则
橙子的博客
09-21 400
设计模式的七大原则
Java高级开发工程师晋升Java架构师述职报告.pptx
07-27
作为架构师的潜力，王智钟展现出强大的专业能力，包括编码能力（代码整洁，逻辑清晰，运用设计模式和多线程技术）、业务梳理能力（通过思维导图理解和表达业务流程）、源码阅读能力（例如对Activiti工作流引擎的深入...
java中级面试题整理
01-28
3. 设计模式：常见的有工厂模式、单例模式、装饰器模式等，是解决软件设计中常见问题的模板。 三、算法 1. HashMap在JDK8的变化：引入红黑树优化，减少哈希冲突，提高性能。 2. 冒泡排序：通过不断交换相邻的逆序...
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 434
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 468
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 459
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1459
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2487
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
09电子设计竞赛题目预测
08-27
根据提供的信息，09电子设计竞赛的题目预测涉及一个前置放大电路的设计。该电路要求在较宽的频带范围内具有良好的直流和交流特性，并包括输入阻抗匹配、无源衰减网络、有源放大等环节，采用单端输入单端输出方式实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值