java的类和继承构造

news2025/1/16 0:57:12

 一些小技巧

类和对象

什么是类，对象，方法？

在下面的 Java 代码中，定义了一个名为 Person 的类，并提供了构造方法来初始化对象的属性。类中定义了 eat、sleep 和 work 三个方法，用于表示人的行为。在 main 方法中，创建了一个名为 p1 的 Person 对象，并调用了其方法来展示人的行为。

通过这样的代码组织，我们可以创建多个不同的 Person 对象，每个对象都有自己独立的属性和行为。

public class Person {
    //属性
    private String name;
    private int age;
    private String gender;

    
    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }


    //方法，也就是行为
    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }

    public void work() {
        System.out.println(name + " is working.");
    }

    public static void main(String[] args) {
        //实例化了一个p1的对象
        Person p1 = new Person("Tom", 25, "male");
        p1.eat();
        p1.sleep();
        p1.work();
    }
}

1）在java中，类只支持单继承，不允许多重继承，也就是说，一个类只能有一个直接的父亲，例如下面这种情况是不合法的

class A{}
class B{}

class C extends A,B
//这种写法是错误的

2）但是多个类可以同时继承一个父亲

class A{}

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

3)多层继承也是可以的

这时候C也可以被称作A的子类

class A{}

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

封装

class Animal{
	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指针的作用

总结

static修饰符

1.静态变量

特点：

1.可以通过类名直接访问

2.静态变量是随着类的加载而加载，是优先于对象出现的

静态变量被所有对象共享，什么意思？

下面是例子，

展示了静态变量可以通过类名访问，且被所有对象共享

调用静态变量的方法

2.静态方法

这里引入了一个新的概念——工具类，借此来整合一下目前遇到的所有类

工具类：帮助我们做一些事情，但是不描述任何事物的类。

特点：

1.见类名知其作用

2.私有化构造方法（使该类无法被示例化）

3.方法定义为静态的（不用实例化对象，也可以调用方法）

举例，计算器的类就可以被看作是工具类，因为不需要实例化对象，只需要调用方法就够了

public class ArrayUtil {
	//私有化构造方法，为了不让外界实例化对象
	private ArrayUtil() {};
	
	//定义为静态方法，方便调用
	public static void printArr(int[] arr) {
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1) {
				sb.append(arr[i]);
			}
			else {
				sb.append(arr[i]);
				sb.append(",");
			}
			
		}
		sb.append("]");
		
		System.out.println(sb.toString());
	}
	
	public static double getAverge(int[] arr) {
		double sum =0;
		for (int i = 0; i < arr.length; i++) {
			sum+=arr[i];
		}
		return sum/arr.length;
	}
	
	
}
public class testCalc {
	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5};
		ArrayUtil.printArr(arr);
		
		double ret = ArrayUtil.getAverge(arr);
		System.out.println(ret);
	}
	
	
}

继承

继承的使用方法和好处

继承的特点

如果一个类没有父类，则默认继承于object 

可以看到，下层子类拥有上层父类的特点

继承的权限

1.子类继承了父类中的哪些内容？

总结：

1.构造方法一律不可以被继承的

2.成员变量一律可以被继承。（但是子类虽然能继承父类的private，却不能访问）

3.成员方法非私有可以被继承，私有不能被继承

2.子类能访问父类中哪些属性？

在子类中，只允许直接访问父类中非private的属性和方法，换句话说，父类中private修饰的属性和方法在子类中无法直接访问，但是可以用getter和setter方法间接访问

class Animal{//父类
    private int age;
    public int getAge(){
        return age;
    }
    String name;
}
class Dog extends Animal{//子类extends(继承)父类
    String color;
    void print(){
        System.out.println(age);//直接访问父类中的private属性，错误！
        System.out.println(name);//父类中的name为default权限，可以访问
    }
}

子类在父类基础上的操作

1.子类在父类基础上扩充属性和方法

子类已经拥有父类的所有属性和方法，扩充子类的属性和方法，让子类描述的对象更加具体

如下。Dog类示例化的对象首先会拥有Animal类的两个属性，并在此基础上扩充了一个颜色属性

class Animal{//这是父类
    int age;
    String name;
}
class Dog extends Animal{//子类extends(继承)父类
    String color;
}

2.对子类继承自父类的方法进行重写（override）

为了满足不同需求，子类可以对父类的方法重写。

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.shout();
    }
}
class Animal{//这是父类
    int age;
    String name;
    void shout(){
        System.out.println("发出了奇怪的叫声");
    }
}
class Dog extends Animal{//子类extends(继承)父类
    String color;
    void shout(){//重写
        System.out.println("发出了汪汪汪的叫声");
    }
}

注意，子类中重写方法的权限不得低于父类中原方法的权限

class Animal{//这是父类
    int age;
    String name;
    void shout(){
        System.out.println("发出了奇怪的叫声");
    }
}
class Dog extends Animal{//子类extends(继承)父类
    String color;
    private void shout(){//这样重写就错了
        System.out.println("发出了汪汪汪的叫声");
    }
}

3.虚方法表

如果A类想调用方法C，是在A类找方法C，找不到去B类找，然后再去C类找，是这样吗？

不是的，因为效率太低了，于是有了虚方法表。

对象类型转化

1.只有当两种类型有继承关系时，才能对象类型转换

2.向上类型转换。即子类转换成父类，这说无需强制类型转换的，因为父类有的东西子类肯定也有。转换完后，只能使用父类中的方法。因为已经变成父类的类型了，自然不能调用子类的方法。语法格式如下

fatherClass obj = new sonClass();

3.向下类型转换（强制类型转换）。这个操作有约束条件的。向下转型通常发生在父类类型的引用指向子类对象的情况下。确保在进行向下转型之前，引用确实指向了正确的子类对象，否则可能会出现运行时异常。

sonClass obj = (sonClass) fatherClass;

interface Animal{
	void eat();
	void sleep();
}

interface Pet extends Animal{
	void play();

	void bark();
}

class Teddy implements Pet{
	public void bark() {
		System.out.println("汪汪汪");
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃骨头");
	}

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("睡懒觉");
	}

	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("和主人玩");
	}
	
}

public class testCalc {
	public static void main(String[] args) {
		//创造Teddy对象并向上转型（无需强制类型转换）
		Pet teddy = new Teddy();
		
		teddy.eat();teddy.sleep();
		teddy.play();
		
		//teddy.bark(); 
		//这样就不行了，因为teddy现在是Pet类型，而bark方法是Teddy类里的
		
		//向下转型（强制类型转换）
		if(teddy instanceof Teddy) {
			//如果teddy此时的类型确实是Teddy类的父类
			//那么可以进行向下转型
			teddy = (Teddy)teddy;
			teddy.bark();
			
		}
		
	}
	
	
}

抽象类

1.为什么要有抽象类？

例如我们定义了一个Person类，里面的work方法是空着的（或者随便写一个，就像图中一样），这是因为，不同的人的工作是不同的，无法统一，因此无法在Person类里把work方法写好，换言之，有不确定的方法体。

需要依靠对象进行重写。

当我们去实例化老师和学生这两个对象的时候，student和teacher两个对象需要对work方法进行重写。但倘若忘记重写或没有重写，就不合适了。为了防止忘记重写的情况发生，我们要用上抽象类来“逼”对象进行重写，怎么个“逼”法？往下看。

像这样定义了一个抽象类，类中的抽象方法，子类必须强制进行重写，否则会报错。

抽象类和抽象方法的定义格式

注意！有抽象方法所在的类必须定义成抽象类！

public abstract class AbstractClass {//抽象类

    // 抽象方法
    //需要注意的是，抽象方法括号()完直接加封号;
    public abstract void abstractMethod();
    

    // 普通方法
    public void concreteMethod() {
        // 方法体
    }
}

当子类继承了抽象类之后，需要重写抽象方法。重写抽象方法的格式如下：

public class ConcreteClass extends AbstractClass {
    @Override
    public void abstractMethod() {
        // 实现抽象方法的具体逻辑
    }
}

抽象类和抽象方法的注意事项

1.抽象类不能实例化

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类可以有构造方法（可以有疑惑，既然不能实例化为什么还要有构造方法呢？因为构造方法可以用于初始化成员变量）

4.抽象类的子类，要么重写抽象类中所有的抽象方法，要么这个子类也是个抽象类

接口

为什么要有接口？

  1. 多继承：Java中的类只支持单一继承，但是通过接口，一个类可以实现多个接口，从而获得了类似于多继承的特性。这使得Java中的类能够更加灵活地组合和复用代码。同时，避免了多继承所带来的复杂性和歧义性。

  2. 解耦：接口可以将抽象和实现分离，从而降低了代码之间的耦合度。使用接口能够让程序更容易扩展和维护，因为实现类只需关注接口定义的方法即可，而不需要关心具体的实现细节。

  3. 规范约束：接口定义了一组行为规范，使得类能够按照这些规范进行设计和实现。这有助于提高代码的可读性、可维护性和可扩展性。

  4. 多态性：接口与多态性密切相关，接口的引用变量可以指向实现了该接口的任何类的对象，从而实现了对不同类的统一处理。

举个例子，现在有个游泳的功能，写到动物类里是不合适的。因为不是所有动物都会游泳，所以可以把游泳功能写成一个接口，单独提供给能游泳的动物。

abstract class Animal{
	//方法有抽象类，那么整个类也要变成抽象类
	
	private String name;
	private int age;
	
	
	
	
	public Animal() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	

	public Animal(String name, int age) {
		super();
		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 abstract void eat();
	//因为每个动物都有自己吃的东西，无法统一行为
	//干脆不写，直接把eat方法修饰为抽象类
	
}

//因为总共有兔子，青蛙，狗三种动物
//兔子不会游泳，所以不能把swim行为加在Animal类里
//但是如果在青蛙和狗的类里单独加Swim，可能会导致不统一
//因为青蛙里的可能叫swim，狗里的叫swimming，这就不统一了
//所以要定义一个swim接口，谁会游泳谁就继承，然后在自己的类里重写即可
interface Swim{
	public void Swim();
}

class Frog extends Animal implements Swim{

	@Override
	public void Swim() {
		System.out.println("蛙泳");
		
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃蚊子");
	}
	
}

class Dog extends Animal implements Swim{

	@Override
	public void Swim() {
		System.out.println("狗刨式");
		
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃骨头");
	}
	
}

class Rabbit extends Animal{

	@Override
	public void eat() {
		System.out.println("吃胡萝卜");
		
	}

	public Rabbit() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Rabbit(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	

	
	
	
}

接口的注意事项

  1. 抽象方法：接口中的方法都是抽象方法，不包含具体的实现代码；

  2. 多继承：Java中的类可以实现多个接口，这使得Java支持了接口的多继承性质；

  3. 关键字：在Java中，使用interface关键字来声明一个接口；

  4. 实现：类通过使用implements关键字来实现一个或多个接口，实现接口的类必须提供接口中定义的所有方法的具体实现；（有点像继承抽象类）

  5. 接口之间的继承：接口可以继承其他接口（但并不实现，因为接口是不包含具体的实现代码），使用extends关键字；

  6. 常量：接口中可以包含常量，这些常量默认为public static final类型；

接口和抽象类的异同

相似之处：

  1. 抽象性：接口和抽象类都是抽象的，它们不能被实例化，只能被子类实现或继承。
  2. 约束子类：它们都可以用于约束子类，使得子类必须实现或重写其中定义的方法。
  3. 实现方法：在接口和抽象类中都可以定义方法的签名而不提供具体实现。

区别：

  1. 方法实现：接口中的方法都是抽象的，没有方法体；而抽象类中可以包含抽象方法，也可以包含具体的方法实现。

  2. 多继承：在Java中，一个类只能继承一个抽象类，但可以实现多个接口。这意味着接口支持多继承，而抽象类不支持。

  3. 构造方法：抽象类可以有构造方法，而接口不能有构造方法。

  4. 成员变量：抽象类中可以包含成员变量，而接口中的变量默认为public static final类型的常量。

  5. 设计目的：抽象类用于表示一种“is-a”关系，即子类是父类的一种特殊类型；而接口更多地用于表示一种“has-a”关系，即类具有某种特定的行为能力。

综上所述，抽象类和接口在某些方面确实有相似之处，但它们的设计目的和使用场景有所不同。一般来说，如果需要表示一种层次结构，并且希望共享代码或者包含成员变量，可以使用抽象类；而如果需要表示一种行为规范，并且希望实现多重继承，可以使用接口。

该怎么规范简洁地写接口？

例题

写之前要先画图，提取共同特征到父类，特殊行为用接口实现

以下的思路对吗？是对的，但不够简洁规范。

因为父类的所有子类都应该是同一种事物，但教练和运动员不是同一种事物，因此可以再分类

修改过后，简洁很多

//因为创建人的对象是没有意义的，
//为了不让外界实例化人，修饰成抽象类
abstract class Person{
	private String name;
	private int age;
	

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public Person() {}

	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;
	};
	
	
	
}


abstract class player extends Person{
	
	
	public player() {
		super();
		// TODO Auto-generated constructor stub
	}

	public player(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	public abstract void learn(); 
	//public abstract void game(); 
}

abstract class coach extends Person{
	
	
	public coach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public coach(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	public abstract void teach(); 
	
}

interface speak{
	public abstract void speadEndlish();
}

class pingpong_Player extends player implements speak{

	
	
	public pingpong_Player() {
		super();
		// TODO Auto-generated constructor stub
	}

	public pingpong_Player(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void speadEndlish() {
		// TODO Auto-generated method stub
		System.out.println("会讲英语");
	}

	@Override
	public void learn() {
		// TODO Auto-generated method stub
		System.out.println("学打乒乓球");
	}
	
}

class basketball_Player extends player{
	

	public basketball_Player() {
		super();
		// TODO Auto-generated constructor stub
	}

	public basketball_Player(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void learn() {
		// TODO Auto-generated method stub
		System.out.println("学打篮球");
	}
	
}

class pingpong_Coach extends coach implements speak{

	
	public pingpong_Coach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public pingpong_Coach(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("教打乒乓球");
	}

	@Override
	public void speadEndlish() {
		// TODO Auto-generated method stub
		System.out.println("会讲英语");
	}
	
}

class basketball_Coach extends coach{

	
	
	public basketball_Coach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public basketball_Coach(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	
	
	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("教打篮球");
	}
	
}



public class testCalc {
	public static void main(String[] args) {
		pingpong_Player p1 = new pingpong_Player("马龙",18);
		System.out.println(p1.getName()+","+p1.getAge());
		p1.learn();p1.speadEndlish();
		System.out.println("-------------------");
		
		pingpong_Coach p2 =  new pingpong_Coach("刘国强",55);
		System.out.println(p2.getName()+","+p2.getAge());
		p2.teach();p2.speadEndlish();
		System.out.println("-------------------");
		
		basketball_Player b1 = new basketball_Player("姚明",20);
		System.out.println(b1.getName()+","+b1.getAge());
		b1.learn();
		System.out.println("-------------------");
		
		basketball_Coach b2 = new basketball_Coach("姚明的教练",50);
		System.out.println(b2.getName()+","+b2.getAge());
		b2.teach();
		System.out.println("-------------------");
		
		
	}
	
	
}

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

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

相关文章

ValueError: ‘x‘ and ‘y‘ must have the same size

ValueError: ‘x‘ and ‘y‘ must have the same size

ValueError: ‘x’ and ‘y’ must have the same size 问题描述 出错代码 axes[0].errorbar(dates_of_observation, observed_lai, yerrstd_lai, fmt"o")X是观测的日期&#xff0c;16天&#xff0c;而且数据也是对应的16个&#xff0c;为什么不对应呢&#xff1f;…
阅读更多...
python工具CISCO ASA设备任意文件读取

python工具CISCO ASA设备任意文件读取

​python漏洞利用 构造payload&#xff1a; /CSCOT/translation-table?typemst&textdomain/%2bCSCOE%2b/portal_inc.lua&default-language&lang../漏洞证明&#xff1a; 文笔生疏&#xff0c;措辞浅薄&#xff0c;望各位大佬不吝赐教&#xff0c;万分感谢。 免…
阅读更多...
git的分支及标签使用及情景演示

git的分支及标签使用及情景演示

目录 一. 环境讲述 二.分支 1.1 命令 1.2情景演练 三、标签 3.1 命令 3.2 情景演示 ​编辑 一. 环境讲述 当软件从开发到正式环境部署的过程中&#xff0c;不同环境的作用如下&#xff1a; 开发环境&#xff1a;用于开发人员进行软件开发、测试和调试。在这个环境中…
阅读更多...
git push origin masterEverything up-to-date

git push origin masterEverything up-to-date

按住这个看一下很简单的问题&#xff0c;我在网上看了很多就是没找到能用的&#xff0c;最后找到了这个看起来写的很简单的一个文章&#xff0c;但他写的真的有用。 出现的问题 解决步骤
阅读更多...
前端开发引入element plus与windi css

前端开发引入element plus与windi css

背景 前端开发有很多流行框架&#xff0c;像React 、angular、vue等等&#xff0c;本文主要讲vue 给新手用的教程&#xff0c;其实官网已经写的很清楚&#xff0c;这里再啰嗦只是为了给新手提供一个更加简单明了的参考手册。 一、打开element plus官网选则如图所示模块安装命令…
阅读更多...
【学习笔记】Understanding LSTM Networks

【学习笔记】Understanding LSTM Networks

Understanding LSTM Networks 前言Recurrent Neural NetworksThe Problem of Long-Term DependenciesLSTM Networks The Core Idea Behind LSTMsStep-by-Step LSTM Walk ThroughForget Gate LayerInput Gate LayerOutput Gate Layer Variants on Long Short Term MemoryConclus…
阅读更多...
go学习之接口知识

go学习之接口知识

文章目录 接口1.接口案例代码展示2.基本介绍3.基本语法4.应用场景介绍5.注意事项和细节6.接口编程经典案例7.接口与继承之间的比较8.面向对象编程--多态1&#xff09;基本介绍2&#xff09;快速入门3&#xff09;接口体现多态的两种形式 9.类型断言1&#xff09;先看一个需求2&…
阅读更多...
odoo16 库存初始化 excel导入问题2

odoo16 库存初始化 excel导入问题2

产品导入模板： excel内容: 导入测试 查看可能的值，发现没有ml，在计量单位中增加ml选项（不选创建，知道为什么不，仔细想想，创建不知ml是什么单位） 位置不能在此导入，故取消 测试正常 导入成功 总结：产品导入时，位置无法指定，只建产品名称，计量单位，采购单位，
阅读更多...
混沌系统在图像加密中的应用（基于哈密顿能量函数的混沌系统构造1.3）

混沌系统在图像加密中的应用（基于哈密顿能量函数的混沌系统构造1.3）

混沌系统在图像加密中的应用&#xff08;基于哈密顿能量函数的混沌系统构造1.3&#xff09; 前言一类三维非哈密顿系统的构造与动态特性分析1.相关理论基础2.类Nos-Hoove系统构造的思路及实现3.基于哈密顿能量理论的Nos-Hoove系统的分析与仿真3.1 平衡点分析3.2 不同强度激励下…
阅读更多...
软件设计师 之 【第三章】数据库系统

软件设计师 之 【第三章】数据库系统

文章底部有个人公众号&#xff1a;热爱技术的小郑。主要分享开发知识、学习资料、毕业设计指导等。有兴趣的可以关注一下。为何分享&#xff1f; 踩过的坑没必要让别人在再踩&#xff0c;自己复盘也能加深记忆。利己利人、所谓双赢。 1、数据库系统前言 2、三级模式 - 两级映射…
阅读更多...
数据结构 | 带头双向循环链表专题

数据结构 | 带头双向循环链表专题

数据结构 | 带头双向循环链表专题 前言 前面我们学了单链表&#xff0c;我们这次来看一个专题带头的双向循环链表~~ 文章目录 数据结构 | 带头双向循环链表专题前言带头双向循环链表的结构实现双向链表头文件的定义哨兵位初始化创建节点尾插尾删头插头删打印查找指定位置前插入…
阅读更多...
DevChat 初探之 RBAC 模型的实现

DevChat 初探之 RBAC 模型的实现

今天我们来尝试一款编程辅助助手 DevChat, 看能不能提升咱们的日常编程效率。作为一款编程助手&#xff0c;我们来看看它与 Copilot, CodeWhisperer 同领域产品的一些区别和特色。定个小目标&#xff0c;通过 DevChat 实现一个简单的 RBAC 模型&#xff0c;小试牛刀一下&#x…
阅读更多...
虚拟机CentOS 8 重启后不能上网

虚拟机CentOS 8 重启后不能上网

情况说明&#xff1a;原本虚拟机是可以上网的&#xff0c;然后嘚一下&#xff0c;重启后&#xff0c;连接不上网络&#xff0c;完了&#xff0c;上网查找一堆质料&#xff0c;我的连接方式是桥接模式&#xff08;复制物理网络连接状态&#xff09;。 好&#xff0c;有人说是vmn…
阅读更多...
C++: 内存管理 (new / delete)

C++: 内存管理 (new / delete)

文章目录 一. C/C 内存分布二. C 语言中动态内存管理方式: malloc/calloc/realloc/free三. C内存管理方式1. new / delete 操作内置类型2. new / delete 操作自定义类型 四. operator new 与 operator delete 函数五. new 和 delete 的实现原理1. 内置类型2. 自定义类型 六. 定…
阅读更多...
双11终极官方战报 凯迪仕智能锁全网全渠道第一 持续领跑智能锁行业

双11终极官方战报 凯迪仕智能锁全网全渠道第一 持续领跑智能锁行业

一年一度双11狂欢盛典暂时落下帷幕&#xff0c;作为下半年最大的电商购物节&#xff0c;本次双11电商平台借机推出优惠券、补贴、折扣等促销活动&#xff0c;激发消费者购物热情。其中&#xff0c;智能门锁等智能家居产品更是取得了亮眼的成交。 据悉&#xff0c;凯迪仕智能锁双…
阅读更多...
自定义Graph Component：1-开发指南

自定义Graph Component：1-开发指南

可以使用自定义NLU组件和策略扩展Rasa&#xff0c;本文提供了如何开发自己的自定义Graph Component指南。   Rasa提供各种开箱即用的NLU组件和策略。可以使用自定义Graph Component对其进行自定义或从头开始创建自己的组件。   要在Rasa中使用自定义Graph Component&#x…
阅读更多...
Pinia 状态管理器 菠萝:Setup Store风格

Pinia 状态管理器 菠萝:Setup Store风格

Pinia介绍&#xff1a; Pinia 是 Vue 的专属状态管理库&#xff0c;它允许你跨组件或页面共享状态。 Pinia 大小只有 1kb 左右&#xff0c;超轻量级&#xff0c;你甚至可能忘记它的存在&#xff01; 相比 Vuex,Pinia 的优点&#xff1a; 更贴合 Vue 3 的 Composition API 风…
阅读更多...
C语言从入门到精通之【数据类型和关键字】

C语言从入门到精通之【数据类型和关键字】

数据类型在程序使用之前已经预先设定好了&#xff0c;在整个程序的运行过程中没有变化&#xff0c;这些称为常量&#xff08;constant&#xff09;。其他数据类型在程序运行期间可能会改变或被赋值&#xff0c;这些称为变量&#xff08;variable&#xff09;。 变量类型有几种…
阅读更多...
golang Copier 数据复制

golang Copier 数据复制

Copier I am a copier, I copy everything from one to another Copier是golang实现的&#xff0c;实现不同数据结构之间数据复制的工具包 github地址 使用方法 以User和Employee之间相互复制为例 使用的版本为 v0.3.5 入门 package mainimport ("fmt""git…
阅读更多...
基于SSM的数据结构课程网络学习平台

基于SSM的数据结构课程网络学习平台

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是 目录…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023