第六章：面向对象基础

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量190 收藏
点赞数
分类专栏： JavaSE学习 文章标签： java 类 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dai_0724/article/details/108528077
版权

第六章：面向对象基础

  • 面向对象和面向过程的区别：

    • 抽象的目的：将复杂的问题简单化

    • 面向过程的抽象： 将几个有区别的物体的共同性质或特性，形象地抽取出来或孤立地进行考虑的行动或过程

    • 面向对象的抽象：

      • 从事物中舍弃个别的非本质特征，抽取共同的本质特征
      • 只考虑与问题域相关的信息，而忽略与问题域不相关的部分
        在这里插入图片描述
        在这里插入图片描述

    • 面向对象思想：面向对象编程思想实际上就是一种运用对象、类、继承、封装、聚合、关联、消息、多态性等概念来构造系统的软件开发方法

      面向对象的分析（OOA，Object Oriented Analysis）
      面向对象的设计（OOD，Object Oriented Design）
      面向对象的编程实现（OOP，Object Oriented Programming）

    • 面向对象概念

      • 对象：是系统中用来描述客观事物的一个实体
      • 类是一组具有相同属性和行为的对象的抽象，类的作用是用来创建对象，对象是类的一个实例
      /**
 * 商品类
 * @author Administrator
 * 类和对象的关系：类是对象的模板，类就是用来产生对象的，对象就是类的具体实例
 *
 */
public class Product {
	/**
	 * 将商品公有的特征抽取出来声明属性(成员变量)
	 * 成员变量定义在类中
	 * 每个的对象都拥有这些属性，只是对应的值不一样，称为成员变量
	 */
	//商品编号
	int pid;
	//名称
	String pname;
	//价格
	int pic;
	//数量
	int pnum;
	//商品描述
	String pdis;
	
	//成员方法
	public void queryProduct() {
		System.out.println("查询商品信息");
	}
	//成员方法
	public boolean updateProduct(int pid) {
		System.out.println("修改商品信息");
		return false;
	}
	
	public static void main(String[] args) {
		//创建一个商品对象
		Product p1=new Product();
		//访问属性：使用“.”运算符访问属性和方法
		System.out.println(p1.pdis);//null
		System.out.println(p1.pnum);//0
		//属性赋值:值的数据类型要和属性的数据类型一致
		p1.pid=1;
		p1.pname="欧拉黑猫";
		p1.pic=9;
		p1.pnum=1000;
		p1.pdis="纯电动车新能源汽车代步神器 一元试驾 订金";
		p1.queryProduct();
		
		System.out.println(p1.pname);//欧拉黑猫
		
		Product p2=new Product();
		p2.pname="长城";
		p2.queryProduct();
		System.out.println(p2.pname);//长城
		
		
		Teacher t=new Teacher();
		t.teaching();
	}
  • 成员变量和局部变量的区别
/**
 * 教师类
 * @author Administrator
 * 变量必须初始化之后才能使用
 * 
 * 局部变量：
 * 		声明在方法体中或者语句块中,作用域范围在声明的语句块中
 * 
 * 成员变量：属于对象的
 * 		声明在类中，作用域范围是整个类
 * 
 * 属性可以和局部变量同名，使用关键字this进行区分
 
	成员方法可以直接调用成员变量和成员方法
 *
 */
public class Teacher {
	//成员变量
	
	int age;
	String name;
	String sex;
	int sal;
	
	public void teaching() {
		int x=20;
		int sal=30;
		System.out.println("成员方法teaching()"+tid);
		System.out.println("成员方法teaching()"+sal);
		//this:表示的是当前实例化对象，你可以看成是对象的引用
		System.out.println("成员方法teaching()"+this.sal);
	}
	
	public void eat() {
		System.out.println("成员方法eat()"+name);
	}
	int tid;
	public static void main(String[] args) {
		Teacher t1=new Teacher();
		t1.tid=1;
		t1.name="张德帅";
		t1.sal=100;
//		t1.eat();
		t1.teaching();
		
		Teacher t2=new Teacher();
		t2.tid=2;
		t2.name="张德美";
		t2.sal=200;
//		t2.eat();
		t2.teaching();
//		System.out.println(t1.name);
//		System.out.println(t2.name);
//		
		
	}
  • 对象的内存
    在这里插入图片描述
/**
 * 变量必须初始化之后才能使用
 * @author Administrator
 * 成员方法必须初始化之后才能使用
 * 属性有默认值，因此可以不用赋值就可以使用
 * 引用对象:默认为null  int:0  double:0.0  boolean:false
 *  */
public class Teacher {
		//成员变量
		int age;
		String name;
		String sex;
		int sal;
		int tid;
		
		public void teaching() {
			eat();
			System.out.println("成员方法teaching()"+name);
		}
		
		public void eat() {
			System.out.println("成员方法eat()"+name);
		}
		
		public static void main(String[] args) {
			int x=30;
			Teacher t1=new Teacher();
			System.out.println(t1);//@7852e922
			System.out.println(t1.age);//0
			System.out.println(t1.name);//null
			t1.name="zhangsan";
			System.out.println(t1.name);//zhangsan
			
			Teacher t2=new Teacher();
			System.out.println(t2);//@4e25154f
			System.out.println(t2.age);//0
		}
		
}
  • 使用对象时注意的问题
//成员变量
	String name;
	int age;
	//成员方法
	public void getName() {
		
	}
	public void setName() {
		getName();
	}
	
	public static void main(String[] args) {
	/**
	 * ①在静态方法和其他类中使用时：成员变量和成员方法必须实例化之后才能调用
	 * ②什么是实例化：就是创建对象，通过new来创建一个对象
	 * ③怎么调用属性和成员方法：引用.方法名;引用.属性
	 * ④什么是引用：引用在java中就是地址的同义词
	 * 
	 */
		Studnet s1=new Studnet();//创建了一个对象
		new Studnet();//创建了一个对象
		new Studnet().setName();
		
	}
  • 垃圾回收机制
/**
 * 垃圾回收：只会回收堆内存的对象
 * 垃圾回收机制:当内存中的对象过多是，垃圾回收线程会自动帮我们回收垃圾
 * 			 当一个对象变成垃圾时，jvm会自动执行垃圾回收--finalize()
 * 			 垃圾回收线程的优先级非常非常低
 * 
 * 什么时候对象会变成垃圾?
 * 		当没有引用指向时，该对象就会变成垃圾
 * 		匿名对象
 * 
 * 
 * @author Administrator
 *
 */

public class Person {
	
	public void getName() {
		System.out.println("我是一万行代码");
		System.out.println("haha");
	}
	//main：主线程
	public static void main(String[] args) {
		
		Person p=new Person();
		p.getName();
		p=null;
		
		//匿名对象：作用--节省内存：当只想对对象执行一次操作时可以声明成匿名对象
		new Person().getName();
		System.out.println("我是一万行代码");
		
		//超出对象的生命周期
		for(int i=0;i<10;i++) {
			Person p1=new Person();
		}
		
		//提升变量的生命周期
		Person p2=null;
		for(int i=0;i<10;i++) {
			p2=new Person();
		}
	  p2.getName();
		
	}

在这里插入图片描述

  • 垃圾回收算法：

    • 复制算法
    • 标记算法
    • gc算法（*）：将新生代（8：1：1）进行分割
      • 8：存放新建的对象–Eden
      • 1：1：两个Survivor

    在这里插入图片描述

  • 构造方法(构造器)

/**
 * 特别强调：1、构造的作用：初始化对象的--成员变量、成员方法    2、方法和变量必须初始化之后才能使用
 * ①构造器也称为构造方法
 * ②语法：方法名和类名相同，没有返回值也没有void 
 * ③无参构造器的作用：初始化对象，给所有的成员变量赋默认值
 * ④new 构造方法()：new:内存空间分配符  完成对象实例化的同时完成了对象的初始化  
 * ⑤构造方法可以重载
 * ⑥当没有提供构造方法时，编译器会默认提供一个无参的构造方法
 * ⑦当一个类中有了有参的构造方法，编译器就不会再提供无参的构造方法，一般我们提供有参的构造方法的同时会提供一个无参的构造方法
 * ⑧有参构造器的作用：初始化对象，
 * 
 * 
 * @author Administrator
 *
 */

public class Teacher {
	int age;
	String name;
	double sal;
	
	
	public Teacher() {
		System.out.println("无参的构造方法");
	}
	
	public Teacher(int age) {
		System.out.println("有参的构造方法"+age);
	}
	public Teacher(int age,String name,double sal) {
		this.age=age;
		this.name=name;
		this.sal=sal;
		System.out.println("有参的构造方法"+age);
	}
	
	public String getResult() {
		return "age:"+this.age+" name:"+this.name+" sal:"+this.sal;
	}

	public static void main(String[] args) {

		Teacher t1=new Teacher();
		System.out.println(t1.getResult());
		t1.age=10;
		t1.name="zhangsan";
		t1.sal=80;
		System.out.println(t1.getResult());

//		System.out.println(t1.getResult());
//		System.out.println(t1.age);
//		Teacher t2=new Teacher(10);
//		System.out.println(t2.age);
		Teacher t2=new Teacher(10,"zhangsan",80);
	}
  • java中包的使用
    • 包允许将类组合成较小的单元
    • 有助于避免命名冲突 :在同一个包中不能有同名的类
    • 包允许在更广的范围内保护类、数据和方
    • 注意：
      • 在java中位于包中的类，在文件系统中的存放位置，必须有与包名层次相对应的目录结构
      • package语句作为java源文件的第一条语句
      • 每个源文件只能声明一个包：只能有一条package语句
      • 如果没有package语句，则默认为无名包
      • 位于同一包中的类可以直接访问并使用
      • 使用不用包中的类时需要导包：import 包名.类名，java.lang是java默认包，java.lang不需要导入，编译器会自动导入java.lang包
      • 导包：package像是我们的姓，而class名称就像是我们的名字 。
      • 如果本包中的类名和其他包中的类名相同时,使用时默认调用本包中的类，如果想使用其他包中的同名的类，实例化时指定包名.类名，例如： 构造器.TestThree t2=new 构造器.TestThree();
  • static关键字
  • 在这里插入图片描述
/**
 * static:静态关键字
 * 注意：
 * 		static不能修饰局部变量只能修饰属性
 * 		成员变量必须实例化之后才能通过引用.变量名 调用
 * 		成员方法可以直接调用成员方法和成员变量:在成员方法被其他类调用时一定是完成对象的初始化
 * 	修饰：
 * 		属性：static修饰的变量称为静态变量(类变量)		
 * 		方法：static关键字修饰的方法称为静态方法(类方法)
 * 		代码块：static修饰的代码块称为静态代码块	
 * 
 * 静态方法和静态变量的访问：
 * 			对象实例化之后通过 引用.静态方法、引用.静态变量
 * 			类名.方法名、类名.静态变量(推荐)
 * @author Administrator
 * 结论：
 * 		1、静态变量和静态方法所有对象共享
 * 		2、静态资源在类加载的时候就完成了初始化，而非静态资源(成员变量和成员方法)是在实例化的
 * 		同时完成初始化工作
 * 		3、类加载一定是在对象实例化之前的，而且类加载只进行一次
 * 		4、静态方法不能直接访问成员方法和成员变量，成员方法可以直接访问静态方法和静态变量,静态方法能直接访问静态变量和方法
 * 		5、静态方法中不能使用this和super关键字
 */

public class Teacher {
	//成员变量
	int age;
	//静态变量(类变量)
	static int sex;
	
	//成员方法
	public void getAge() {
		getSex();
		System.out.println("成员方法getAge"+sex);
	}
	
	//成员方法
	public void getAge1() {
		getAge();
		System.out.println("成员方法getAge1"+age);
	}
	
	//静态方法
	public static void getSex() {
//		System.out.println(this.age);
//		getAge1();not
		System.out.println("静态方法"+sex);
	}
	
	public static void main(String[] args) {
		Teacher.getSex();
		Teacher t=new Teacher();
		t.getAge();
//		Teacher t1=new Teacher();
//		t1.age=20;
//		t1.sex=2;
//		Teacher.sex=3;
//		System.out.println("age:"+t1.age);
//		System.out.println("sex:"+t1.sex);//3
//		
//		Teacher t2=new Teacher();
//		t2.age=18;
//		System.out.println("age:"+t2.age);
//		System.out.println("sex:"+t2.sex);//3
//		
//		Student s=new Student();	
	}
//	public static void main(String[] args) {
//		Teacher t=new Teacher();
		t.getAge1();	
//		//静态方法的调用
//		t.getSex();//静态方法
//		System.out.println(t.sex);//0
//
//		Teacher.getSex();
//		System.out.println(Teacher.sex);
		t.age=20;
		System.out.println(t.age);//20
		System.out.println(sex);//0
//		
//	}
  • this()和this关键字
/**
 * this 当前实例化对象;
 * this(参数列表)：指的是构造方法
 * 		*:对象初始化只进行一次，this(参数列表)只能在构造其中被调用
 * 		①this(参数列表)必须放在构造器第一行
 * 		②一个构造器中只能调用一个this(参数列表)
 * 		③this(参数列表)：通过传入的参数判断调用的是哪一个构造器
 * @author Administrator
 *
 */
public class Student {
	String name;
	int age;
	
//	public Student() {
//		System.out.println("无参的构造方法");
//	}
	
	public Student() {
//		this();
//		this("lisi",20);
//		this("zhansan");
		System.out.println("无参的构造方法");
		
	}
	public Student(String name) {
		this.name=name;
	}
	
	public void getName() {
		
	}
	
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("有参的构造方法");
	}
	

	public static void main(String[] args) {
		Student s1=new Student();
//		System.out.println(s1.age);//0  在没有调用this()之前；
		System.out.println(s1.age);//20  在没有调用this()之后；

		Student s2=new Student("zhangsan",10);
		System.out.println(s2.age);
	}
  • 构造代码块和静态代码块
/**
 * 构造代码块(成员代码块)：
 * 		{
 * 			完成对象初始化工作
 * 		}
 * 
 * 对象实例化过程：构造代码块--构造方法
 * 			编译器会自动将构造代码块放在构造器第一行
 * @author Administrator
 *
 */
public class Person {
	int age;
	String name;
	
	public Person() {
//		{
//			System.out.println("构造代码块");
//		}
		
		System.out.println("构造方法");
	}
	
	
	public Person(int age, String name) {
	
		this.age = age;
		this.name = name;
	}

	{
		this.age=20;
		this.name="张三";
		System.out.println("构造代码块");
	}

//	{
//		this.age=0;
//		this.name=null;
//		System.out.println("构造代码块");
//	}
	
	
	public static void main(String[] args) {
		Person p=new Person();
		System.out.println(p.age);
	}


/**
 * 静态代码块：
 * 	static{
 * 		完成静态资源初始化
 * 	}
 * @author Administrator
 * 
 * 静态代码块执行一次而可以实例化多个对象--类加载一次可以实例化多个对象
 * 类加载只进行一次
 * 
 * 对象实例化过程：先类加载--初始化(实例化)
 *  */
public class Order {
	int age;
	static int sxe;
	
	public Order() {
		System.out.println("Order构造方法");
	}
	
	static {
		sxe=0;
		System.out.println("Order静态代码块");
	}

	public static void main(String[] args) {
		Order o1=new Order();
//		Order o2=new Order();
		Student s1=new Student();
		

	}
  • 类加载的过程
  • 在这里插入图片描述
public class Person {
	int age;
	static int sex=20;
//	static Student s=new Student();
	
	
	public Person() {
		
		System.out.println("构造方法");
	}
	
	static {
		System.out.println("静态代码块");
	}

	public static void main(String[] args) {
		Person p=new Person();
		Person p1=new Person();
		

	}
  • 单例模式
    • 保证一个类在内存中只有一个实例(对象)
    • 作用：节省内存
    • 注意：使用单例模式的类，尽量不要在类中声明成员变量，声明也是声明常量，避免并发访问出现数据不一致的问题
    • 在这里插入图片描述
/**
 * 懒汉式：
 * 实现单例模式的规则：
 * 		①提供一个私有构造器
 * 		②提供私有的、静态的自身属性的静态变量
 * 		③提供一个返回自身的静态公有方法
 * 
 * 
 * @author Administrator
 *
 */

public class Student_lazy{
	
	private Student_lazy() {
		System.out.println("实例化了");
	}
	
	private static Student_lazy student_lazy;
	
	public static Student_lazy getStudentInstance_lazy() {
		if(student_lazy==null) {
			student_lazy=new Student_lazy();
		}
		return student_lazy;
		
	}
	
	
	public static void main(String[] args) {
		System.out.println(student_lazy);
	}
  • 测试单例

	public static void main(String[] args) {
//		Teacher t1=new Teacher();
//		t1.getResult();
//		Teacher t2=new Teacher();
//		t2.getResult();
//		Teacher t3=new Teacher();
//		Teacher t4=new Teacher();
//		Teacher t5=new Teacher();
//		Teacher t6=new Teacher();
//		Teacher t7=new Teacher();
//		Student_lazy s1=new Student_lazy();
		Student_lazy s1=Student_lazy.getStudentInstance_lazy();
		System.out.println(s1);//@7852e922
		Student_lazy s2=Student_lazy.getStudentInstance_lazy();
		System.out.println(s2);//@7852e922
		
		// == 比较两个引用数据类型变量时比较的是地址
		System.out.println(s1==s2);
		
		Student_hungry s3= Student_hungry.getStudentInstance_hungry();
		System.out.println(s3.age);
		Student_hungry s4= Student_hungry.getStudentInstance_hungry();
		System.out.println(s4.age);
		System.out.println(s3==s4);

	}
二三子_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动手学Python系列之Python面向对象编程（二）
尚拙的博客
10-11 520
上一篇文章我们简单的介绍了面向对象编程和面向过程编程，并详细详细介绍了面向对象编程的一些术语，接下来，我们将继续学习面向对象编程，简单介绍类和对象，面向对象三大特征，及面向对象重载和重写。 Part.1类和对象 面向对象中最重要的概念是类和对象，类是对于现实世界抽象的模板，对象是根据类创建出来的一个个具体的实例 。以动物为例，我们知道，动物是对于现实世界中物种的抽象，具体的猫狗鸡鸭等均可称为动物，动物可以作为一个类，那猫和狗也可以称之为对象。 在python中，我们用 class 来定义类，比如.
第六章：面向对象
xiangchi7的博客
10-30 219
文章目录第一节：关于类==面向对象====类的封装====类的私有成员====类的继承与多继承====类的专有方法====类的多态====静态方法和类方法==第二节：装饰器==私有属性访问器====property装饰器====无参装饰器====带参装饰器====使用类定义装饰器====例：时间统计装饰器==第三节：模块和类库==使用系统标准库 ====安装和使用第三方库 ====使用自己写的类库...
类的定义与实例化
m0_61801103的博客
02-27 1382
目录 类的定义： 类的实例化 this引用： 类的定义： 在java中定义类需要class关键字 语法： class Text { //成员变量； //成员方法； } 注意事项： 1.一个文件一般只能定义一个类。 2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法) 3. public修饰的类必须要和文件名相同 4. 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改 类的实例化 定
3.2、抽象一个类和实例化对象
笨小孩
03-28 7135
一、抽象一个类 二、实例化对象 1、实例化对象 2、对象类型在内存中分配情况 三、$this 四、构造函数和析构函数
类和对象（类和类的实例化，this,static关键字，封装）
weixin_47792933的博客
08-09 468
这里写目录标题类和对象的初步认识面向对象和面向过程类和类的实例化类的成员方法 (method)static 关键字二级目录三级目录 类和对象的初步认识 类就是一类对象的统称。对象就是这一类具体化的一个实例。类是对对象特征的大致描述，类就是类型，表示这一类对象，通过这种类型可以定义很多的对象。如人类这种类型，有姓名，身高，体重，性别，肤色等属性，那么通过这种类就可以定义对象了，对象就是人，这些人，可以是吴签，易烊千玺，毛不易，张三，李四等。这些人，有些能唱歌，跳舞，有些能打球，学习什么的。 面向对象和面向过
类，实例，对象，生成对象，实例化对象的区别(精讲)
jake_Aaron的博客
02-07 8312
问题简述 什么是类？ 什么是实例？ 什么是对象？ 什么是生成对象？ 什么是实例化对象？ 分析问题： 在面向对象程序设计中,"类"在实例化之后叫做一个"实例"（Person person = new Person()）。 "类"是静态的,不占进程内存,而"实例"拥有动态内存。 实例(instance)和对象(object)的区别: 对象就是类的实例,所有的对象都是类的实例,但并不是所有的实例都是对象。 抽象类被定义为...
第6章 面向对象基础（中）
m0_67991849的博客
05-24 568
JavaSE_第6章 面向对象基础–中 教学目标 理解封装的概念 掌握权限修饰符的使用 掌握成员变量的私有化 能够写出类的继承格式 能够说出继承的特点 能够说出方法重写的概念以及和重载的区别 能够应用多态解决问题 理解向上转型与向下转型 能够使用instanceof关键字判断对象类型 掌握构造器的声明与使用 能够使用this关键字解决问题 能够使用super关键字解决问题 了解实例初始化过程 了解Object类的常用方法 会重写Object的常用方法 了解JavaBean概
第章面向对象编程基础ppt课件.ppt
11-13
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它基于“对象”的概念，用于构建复杂的软件系统。在Java语言中，OOP是其核心特性，所有的程序都是由类（Class）和对象（Object）构成的。 1....
第5章-JAVA面向对象编程基础.ppt
11-21
JAVA面向对象编程基础 ...本章内容涵盖了 JAVA 面向对象编程的基础知识，包括定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等，旨在帮助读者掌握 JAVA 面向对象编程的基础知识和技能。
第 5 章：面向对象方法学.zip
12-14
1. 面向对象编程（OOP）基础 - 类与对象：类是对象的模板，定义了对象的属性（数据成员）和行为（方法）。对象是类的实例，拥有类所定义的特性。 - 封装：通过类隐藏内部实现细节，只暴露必要的接口与外界交互，...
第09章 高级部分：面向对象
09-12
本章“第09章 高级部分：面向对象”将深入探讨这一主题，旨在帮助你理解并熟练运用面向对象编程思想。 在Python中，面向对象编程主要涉及以下四个关键概念： 1. **类（Class）**：类是面向对象编程的基础，可以...
C面向对象程序设计第二章.ppt
11-15
C++ 是一种支持面向对象编程的强类型、编译型语言，由Bjarne Stroustrup在C语言的基础上扩展而来。在C++ 中，面向对象的主要概念包括类、对象、封装、继承和多态性。 第二章主要讨论了以下几个关键知识点： 1. **...
类的定义和类的实例化_01(学习笔记)
weixin_59472404的博客
09-07 264
笨方法学习,再学不会,怎么办???
详解Java类、对象、实例化
Smile&搁浅
11-06 8886
Java是一种面向对象的语言。由于具有面向对象特性的语言，Java支持以下基本概念： 多态性 继承 封装 抽象化 类 对象 实例 方法 消息解析 在本章中，我们将探讨类和对象这些概念。对象 - 对象具有状态和行为。例如：狗有状态 - 颜色，名称，繁殖以及行为，摇头晃脑，吠叫，吃。对象是类的实例。类 - 一个类可以被定义为描述行为的模板/蓝色印花/指
类与对象（一）
xxtzzxx的博客
03-04 383
一、什么是面向过程、面向对象？ 1、面向过程 C语言是面向过程的典型代表，其关注的是解决问题的过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 2、面向对象 C++是基于面向对象的，其关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 3、形象说明 面向过程 -- 吃狗屎 面向对象 -- 狗吃屎 （虽然比较恶心，但是话糙理不糙，希望你不是在边吃边看） 二、类 1、类的引入 事实上，C++中的类和C语言中的结构体的用法上有诸多的共通之处，C++兼容C中结构体的用法，同时也
golang 接口
m0_70982551的博客
07-24 940
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 509
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 633
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 589
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值