Java常见类

最新推荐文章于 2024-12-25 22:13:00 发布
最新推荐文章于 2024-12-25 22:13:00 发布
阅读量277 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zp_support/article/details/125949893
这篇博客详细介绍了Java中的核心类，包括包装类的装箱拆箱、整数缓冲区，String类的不变性和常用方法，正则表达式的概念，大数值运算类BigInteger和BigDecemal，日期处理的Data、SimpleDateFormat和Calendar类，Math类的数学运算，Random的随机数生成，Runtime和System类的功能，以及枚举的语法、特点和优势。

一、包装类

1.1 概述

概述:

  • 基本数据类型所对应的引用数据类型。
  • Object可统一所有数据，包装类的默认值是null。
/**
	包装类:
	byte	short	int	      long	float	double	char	  boolean
	Byte	Short	Integer   Long	Float	Double	Character Boolean
 */
public static void main(String[] args) {	
	Integer num1 = Integer.valueOf(100); // 反编译的 -- Integer.valueOf
	Integer num2 = 100;	
	System.out.println(num1 == num2);	// 结果为false
}

2.2 装箱、拆箱

  • 八种包装类提供不同类型间的转换方式。

  • Number父类中提供的6个共性方法。

    • parseXXX()静态方法（除了Character）。
    • valueOf()静态方法。

  • 注意：需保证类型兼容，否则抛出NumberFormatException异常。

  • JDK 5.0之后，自动装箱、拆箱。基本数据类型和包装类自动转换。

3.3 整数缓冲区

  • Java预先创建了256个常用的整数包装类型对象。
  • 在实际应用当中，对已创建的对象进行复用。

面试题：分析以下输出结果的原因。

public class TestInteger2 {
	public static void main(String[] args) {
		//面试题
		Integer integer1=new Integer(100);
		Integer integer2=new Integer(100);
		System.out.println(integer1==integer2);		
		Integer integer3=Integer.valueOf(100);//自动装箱Integer.valueOf
		Integer integer4=Integer.valueOf(100);
		System.out.println(integer3==integer4);//true	
		Integer integer5=Integer.valueOf(200);//自动装箱
		Integer integer6=Integer.valueOf(200);
		System.out.println(integer5==integer6);//false		
	}
}

二、String类

2.1 概述:

  • Java程序中的所有字符串文本（例如“abc”）都是此类的实例。

  • 字符串字面值是常量，创建之后不可改变。

  • 常用创建方式：

    • String str1 = “Hello”;
    • String str2 = new String(“World”);

2.2 常用方法:

方法名描述
public char charAt(int index)根据下标获取字符
public boolean contains(String str)判断当前字符串中是否包含str
public char[] toCharArray()将字符串转换成数组。
public int indexOf(String str)查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int length()返回字符串的长度
public String trim(）去掉字符串前后的空格
public String toUpperCase()将小写转成大写
public boolean endsWith(String str)判断字符串是否以str结尾
public String replace(char oldChar,char newChar)将旧字符串替换成新字符串
public String[] split(String str)根据str做拆分
public String subString(int beginIndex,int endIndex)在字符串中截取出一个子字符串

2.3 split():

打断字符串 — 返回一个字符串数组

案例：将字符串打断，转换为对象，存入对象数组中（前端返回字符串数据，后端的加工）

1.创建对象类（便于访问就不加访问修饰符）

public class Student {
	String name;
	int age;	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}	
}

2.操作

public class TestSplit {
	public static void main(String[] args) {
		// 字符串转对象的思想（重点）
		String students = "name=张三丰,age=20;name=郭襄,age=10;name=华筝,age=6";
		
		String[] stustr = students.split(";"); // 分割每一条数据，返回字符串数组
		
		Student[] stus  = new Student[stustr.length]; // 创建学生数组		
		// 打印分割的字符串数组
//		for (String string : stustr) {
//			System.out.println(string);
//		}		
		for (int i = 0; i < stustr.length; i++) {
			String s = stustr[i];  // 保存为字符串
			Student stu = new Student(); // 创建学生对象
			stu.name = s.split(",")[0].split("=")[1];  // 打断后，个姓名赋值
			stu.age = Integer.parseInt(s.split(",")[1].split("=")[1]);  // 打断后，给年龄赋值
			stus[i] = stu;  // 存到学生数组中
		}
		System.out.println(Arrays.toString(stus));  // 打印
	}
}

2.4 可变字符串

  • 概念：可在内存中创建可变的缓冲空间，存储频繁改变的字符串。
  • Java中提供了两个可变字符串类：
    • StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。
    • StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。
    • 这两个类中方法和属性完全一致。

常用方法：

方法名属性
public StringBuilder append(String str)追加内容。
public StringBuilder insert(int dstOffset, CharSequence s)将指定 字符串插入此序列中。
public StringBuilder delete(int start, int end)移除此序列的子字符串中的字符。
public StringBuilder replace(int start, int end, String str)使用给定字符串替换此序列的子字符串中的字符。start开始位置、end结束位置。
public int length()返回长度（字符数）。

StringBuilder效率高于String。

三、正则表达式

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。

正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。

四、大数值运算类

4.1 BigInteger

为什么使用：

​ double是近似值存储，和金钱相关的就不符合要求了，这是就需要使用BigInteger

特点：大，构造的时候要使用字符串构造

​ 不能自动装箱拆箱，意味着不能直接赋基本数据类型，必须要new

要调用方法来运算

add,substract multiply,divide

// 大数值运算
public class TestBig {
	public static void main(String[] args) {
		String str = "";
		for (int i = 1; i <= 100; i++) {
			str +=i;
		}		
		BigInteger bi1 = new BigInteger(str);
		BigInteger bi2 = new BigInteger(str.substring(10));		
		// 大数值的运算 - 加减乘除
		System.out.println(bi1.add(bi2));
		System.out.println(bi1.subtract(bi2));
		System.out.println(bi1.multiply(bi2));
		System.out.println(bi1.divide(bi2));
	}
}

4.2 BigDecemal

和BigInteger差不多

  • 位置：java.math包中。
  • 作用：精确计算浮点数。
  • 创建方式：BigDecimal bd=new BigDecimal(“1.0”)。
import java.math.BigDecimal;
public class TestBigDecimal {
	public static void main(String[] args) {
		BigDecimal bd1 = new BigDecimal("0.09");
		BigDecimal bd2 = new BigDecimal("0.01");
		System.out.println(0.09 + 0.01);//0.09999999999999999
		System.out.println(bd1.add(bd2));//0.10
	}
}

五、日期

5.1 Data类

  • Date表示特定的瞬间，精确到毫秒。
  • Date类中的大部分方法都已经被Calendar类中的方法所取代。
  • 时间单位
    • 1秒=1000毫秒
    • 1毫秒=1000微秒
    • 1微秒=1000纳秒
Date date = new Date();
System.out.println(date.getTime());
// 运行结果: (1970-01-01 到现在的毫秒数)

5.2 SimpleDateFormat类

  • SimpleDateFormat是以与语言环境有关的方式来格式化和解析日期的类。
  • 进行格式化（日期 -> 文本）、解析（文本 -> 日期）。
字母日期或时间
y年
M月
d日
H时
m分
s秒
S毫秒
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");	System.out.println(sdf.format(System.currentTimeMillis())); 
// 2022-07-09 10:27:49

5.3 Calendar类

  • Calendar提供了获取或设置各种日历字段的方法。
  • protected Calendar() 构造方法为protected修饰，无法直接创建该对象。

常用方法：

方法说明
static Calendar getInstance()使用默认时区和区域获取日历
void set(int year,int month,int date,int hourofday,int minute,int second)设置日历的年、月、日、时、分、秒。
int get(int field)返回给定日历字段的值。字段比如年、月、日等
void setTime(Date date)用给定的Date设置此日历的时间。Date-Calendar
Date getTime()返回一个Date表示此日历的时间。Calendar-Date
void add(int field,int amount)按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillis()毫秒为单位返回该日历的时间值
// Calendar
		Calendar c = Calendar.getInstance();
		System.out.println(c.getTime());// date.getTime()、System.currentTimeMillis()和c.getTime()				
		System.out.println("今天是今年的第几天:" + c.get(Calendar.DAY_OF_YEAR));
		System.out.println("今天是今年的第几周:" + c.get(Calendar.WEEK_OF_YEAR));

六、Math类

6.1 Math

Math 类提供了一序列基本数学运算和几何函数的方法。

Math类是final类，并且它的所有成员变量和成员方法都是静态的。

math的常量:

public static final double E = 2.7182818284590452354;
public static final double PI = 3.14159265358979323846;

math的方法:

Math内的所有方法均为静态的。

方法描述
double sin(double a)角a(弧度)的正弦值
double cos(double a)角a(弧度)的余弦值
double pow(double a,double b)a的b的方法
double sqrt(double a)求平方根
int abs(int a)求绝对值
double ceil(double a)返回大于等于a的最小整数的double值
double floor(double a)返回小于等于a的最大整数的double值
int max(int a, int b)返回int型值a和b中的较大值
int min(int a, int b)返回int型值a和b中的较小值
int round(float a)四舍五入返回整数
double random()返回带+的double值，该值大于等于0.0且小于1.0
// 部分列子
public class TestMath {
	public static void main(String[] args) {
		// Math类 -- 数学类
		System.out.println(Math.abs(Integer.MIN_VALUE)); // 绝对值 (最小值有问题 和int的范围有关)
		System.out.println(Math.pow(2, 3));
		// 90是弧度 -- 度 = 弧度*π/180 
		System.out.println(Math.sin(90*Math.PI/180));
		System.out.println(Math.signum(0)); // 符号函数(了解)
        
        System.out.println(Math.round(1.2345));
		System.out.println(Math.random()); // (随机的) 0-1之间的小数
	}	
}

6.2 静态导入

想直接写方法名或者变量名，则可以考虑使用静态导入

语法：import static 包名.类名.*; //导入该类下的所有静态方法和常量

// 静态导入
import static java.lang.Math.random;
public class TestStaticImport {
	public static void main(String[] args) {
		// 生成0-1之间的随机数
		//使用静态导入，可以直接使用导入的方法
		System.out.println(random()); 		
	}	
}

七、Random类

生成随机数 （伪随机）

伪随机：

​ 实际上这个随机数的生成是由线性同余的算法确定，如果种子一样，生成是数据是一样的

// 无参构造 
public Random() {
    this(seedUniquifier() ^ System.nanoTime());
}
// 带参构造
public Random(long seed) {
     if (getClass() == Random.class)
         this.seed = new AtomicLong(initialScramble(seed));
     else {
         // subclass might have overriden setSeed
         this.seed = new AtomicLong();
         setSeed(seed);
     }
}
// 生成随机数：
public int nextInt(int bound) {
    if (bound <= 0)
        throw new IllegalArgumentException(BadBound);
    int r = next(31);//生成31位的随机数
    int m = bound - 1;//100-1=99
    //01111 10000  
    if ((bound & m) == 0)  // i.e., bound is a power of 2 
        r = (int)((bound * (long)r) >> 31);
    else {
        for (int u = r;
             u - (r = u % bound) + m < 0;
             u = next(31))
            ;
    }
    return r;
}

结论：随机数生成与随机数种子相关，种子可以自己设置，也可以默认使用系统时间生成

八、Runtime类

Runtime代表Java程序的运行时环境，可以通过 getRuntime 方法获取当前运行时。

​ 应用程序不能自己创建Runtime对象，可以通过Runtime的静态方法getRuntime()获得Runtime对象。

Runtime类可以访问jvm的相关信息，如处理器数量，内存信息等

public class TestRuntime {
	public static void main(String[] args) {
		Runtime rt = Runtime.getRuntime(); // 
		// 核数，可以在操作系统中设置
		System.out.println("处理器数量:"+rt.availableProcessors());
		// 空闲的空间-已将拿到的没有用完的空间 (剩余空间随着对象的生成要减少)
		System.out.println("空闲内存:"+rt.freeMemory());   
		// 最大空间 (最大空间跟虚拟机参数有关)
		System.out.println("分配的最大内存:"+rt.maxMemory()); 
		// 总空间 - 已经获取的 (随着对象的创建增加)
		System.out.println("已获得的内存:"+rt.totalMemory()); 
	}
}

九、System类

System系统类，主要用于获取系统的属性数据和其他操作。

常用方法：

方法名描述
static void arraycopy(…)复制数组
static long currentTimeMillis()获取当前系统时间，返回的是毫秒值
static void gc();建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status)退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm。
// System.setOut(System.err);// 可以设置输出类型
System.out.println("测试！"); // 输出结果为黑色字体
System.err.println("测试！"); // 输出结果为红色字体
// 获取当前系统时间 -- long
System.out.println(System.currentTimeMillis());

// 获取系统参数
Properties properties = System.getProperties();
for (Object key : properties.keySet()) {
    System.out.println(key+"-"+properties.getProperty(key.toString()));
}

运行结果:
java.specification.version-15
sun.cpu.isalist-amd64
sun.jnu.encoding-GBK
java.class.path-E:\qf2201workspace\cdjava2206\cdjava2206-\bin
java.vm.vendor-Oracle Corporation
sun.arch.data.model-64
user.variant-
java.vendor.url-https://java.oracle.com/
java.vm.specification.version-15
os.name-Windows 10
sun.java.launcher-SUN_STANDARD
user.country-CN
sun.boot.library.path-E:\java-c-sql\java\eclipse软件\eclipse\plugins\org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_15.0.1.v20201027-0507\jre\bin
sun.java.command-com.qf.cd2206.myday15_class2.classt.TestSystem
jdk.debug-release
sun.cpu.endian-little
user.home-C:\Users\86138
user.language-zh
java.specification.vendor-Oracle Corporation
java.version.date-2020-10-20
java.home-E:\java-c-sql\java\eclipse软件\eclipse\plugins\org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_15.0.1.v20201027-0507\jre
file.separator-\
java.vm.compressedOopsMode-Zero based
line.separator-

java.vm.specification.vendor-Oracle Corporation
java.specification.name-Java Platform API Specification
user.script-
sun.management.compiler-HotSpot 64-Bit Tiered Compilers
java.runtime.version-15.0.1+9-18
user.name-86138
path.separator-;
os.version-10.0
java.runtime.name-OpenJDK Runtime Environment
file.encoding-GBK
java.vm.name-OpenJDK 64-Bit Server VM
java.vendor.url.bug-https://bugreport.java.com/bugreport/
java.io.tmpdir-C:\Users\86138\AppData\Local\Temp\
java.version-15.0.1
user.dir-E:\qf2201workspace\cdjava2206\cdjava2206-
os.arch-amd64
java.vm.specification.name-Java Virtual Machine Specification
sun.os.patch.level-
java.library.path-E:\java-c-sql\java\eclipse软件\eclipse\plugins\org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_15.0.1.v20201027-0507\jre\bin;C:\windows\Sun\Java\bin;C:\windows\system32;C:\windows;E:/java-c-sql/java/eclipse软件/eclipse//plugins/org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_15.0.1.v20201027-0507/jre/bin/server;E:/java-c-sql/java/eclipse软件/eclipse//plugins/org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_15.0.1.v20201027-0507/jre/bin;E:\HW\VMware\bin\;%CATALINA_HOME%\lib;%CATALINA_HOME%\bin;E:\JDKMAV\Java\jdk1.8.0_221\jre\bin;E:\JDKMAV\apache-maven-3.8.4-bin\apache-maven-3.8.4\bin;C:\Program Files (x86)\Common Files\Oracle\Java\javapath;C:\windows\system32;C:\windows;C:\windows\System32\Wbem;C:\windows\System32\WindowsPowerShell\v1.0\;C:\windows\System32\OpenSSH\;C:\Program Files (x86)\NVIDIA Corporation\PhysX\Common;C:\Program Files\NVIDIA Corporation\NVIDIA NvDLISR;E:\互传\EasyShare\x86\;E:\互传\EasyShare\x64\;E:\node\;E:\Pycharm\Graphviz\bin\;E:\Redis\;C:\Users\86138\AppData\Local\Programs\Python\Python35\Scripts\;C:\Users\86138\AppData\Local\Programs\Python\Python35\;E:\JDKMAV\Java\jdk1.8.0_221\bin;E:\Python\Scripts\;E:\Python\;C:\Users\86138\AppData\Local\Microsoft\WindowsApps;E:\Pycharm\PyCharm Community Edition 2021.2.1\bin;;E:\JDKMAV\apache-maven-3.8.4-bin\apache-maven-3.8.4\bin;%CATALINA_HOME%\lib;%CATALINA_HOME%\bin;C:\Users\86138\AppData\Roaming\npm;GRAPHVIZ_DOT;E:\Pycharm\Graphviz\bin;;E:\java-c-sql\java\eclipse软件\eclipse;;.
java.vm.info-mixed mode
java.vendor-Oracle Corporation
java.vm.version-15.0.1+9-18
sun.io.unicode.encoding-UnicodeLittle
java.class.version-59.0

十、 枚举

枚举（enum）全称为 enumeration， 是 JDK 1.5 中引入的新特性。

10.1 语法:

public enum Color{
    //默认添加 public static final Color
    RED,GREEN,BLUE;
}

10.2 本质:

尽管枚举看起来像是一种新的数据类型，实际上，枚举就是一种受限制的类，并且具有自己的方法。创建自己的enum类时，这个类继承自 java.lang.Enum。

public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable{
    ...
}

枚举的值是不会变的 – 封装的思想

Grade.values()[0] = Grade.SENIOR;
System.out.println(Grade.values()[0]); // LOWER

创建一个枚举:

public enum Grade {  // 默认继承了Enum, 因为java是单继承的，所以枚举不能再继承了，只能实现接口
	LOWER,MIDDLE,SENIOR; // //默认添加 public static final Grade
}

反编译:

public final class Grade extends Enum
{
	public static final Grade LOWER;
	public static final Grade MIDDLE;
	public static final Grade SENIOR;
	private static final Grade ENUM$VALUES[];
    // 是一个私有的构造 - 所以枚举不能实例化对象
	private Grade(String s, int i)
	{
		super(s, i);
	}
	public static Grade[] values()
	{
		Grade agrade[];
		int i;
		Grade agrade1[];
		System.arraycopy(agrade = ENUM$VALUES, 0, agrade1 = new Grade[i = agrade.length], 0, i);
		return agrade1;
	}   
	//把一个字符串转为对应的枚举类型
	public static Grade valueOf(String s)
	{
		return (Grade)Enum.valueOf(com/qf/cd2206/myday15_class2/enu/Grade, s);
	}
	static //初始化枚举对象的
	{
		LOWER = new Grade("LOWER", 0);
		MIDDLE = new Grade("MIDDLE", 1);
		SENIOR = new Grade("SENIOR", 2);
		ENUM$VALUES = (new Grade[] {
			LOWER, MIDDLE, SENIOR
		});
	}
}

枚举的初始化过程
1、在静态代码块中new 自己的对象，构造函数使用自身的私有构造
2、枚举类会自动生成values方法，这个方法返回枚举类中所有元素的数组的拷贝。

10.3 特点:

  • 枚举就是一个受限制的类，默认继承Enum
  • 枚举的第一行必须定义该枚举类型的对象
  • 枚举类型对象默认添加： public static final 类型
  • 枚举没有继承明确类（自定义枚举类默认继承Enum，Enum默认继承Object）
  • 枚举类不能被继承
  • 枚举里可以有构造方法、成员方法、静态方法、抽象方法
  • 枚举可以实现接口
  • 枚举里没有定义方法，可以在最后一个对象后面加逗号、分号或什么都不加

10.4 优势:

  • 增强代码可读性

  • 枚举型可直接与数据库交互

  • switch语句优势

  • 编译优势

（枚举类编译时，没有把常量值编译到代码中，即使常量值发生改变，也不会影响引用常量的类 ）

  • 将常量组织起来，统一管理
  • 去除equals两者判断 由于常量值地址唯一，使用枚举可以直接通过“==”进行两个值之间的对比，性能会有所提高

10.5 方法:

方法名解释
Enum.valueOf(Class enumType, String name)根据字符串找到该枚举类中的对象
public static void values()获取该枚举类对象数组
public static void valueOf(String args0)根据字符串获取该枚举类中的对象
public final String name()获取该枚举对象名字
public final Class getDeclaringClass()获取枚举对象的枚举类型相对应的Class对象
public final int hashCode()获取该枚举对象的hash值
public final int compareTo(E o)两个枚举对象进行比较
public final boolean equals(Object other)比较两个枚举对象是否相同

根据字符串获得枚举

Grade sen = Grade.valueOf("SENIOR");
System.out.println(sen); // SENIOR

10.6 案例分析 – 状态码

// 这个枚举的名字叫数据结果--编码--描述
public enum DataResult {	
	SUCCESS(0,"成功"),ERR1(1,"page not found"),ERR2(2,"server internal error");	
	Integer code; // 错误编码
	String msg;  // 错误信息	
	private DataResult(Integer code, String msg) {
		this.code = code;
		this.msg = msg;
	}
	public Integer getCode() {
		return code;
	}
	public void setCode(Integer code) {
		this.code = code;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}	
}
// 这个枚举的名字叫数据结果--编码--描述
public enum DataResult {	
	SUCCESS(0,"成功"),ERR1(1,"page not found"),ERR2(2,"server internal error");	
	Integer code; // 错误编码
	String msg;  // 错误信息	
	private DataResult(Integer code, String msg) {
		this.code = code;
		this.msg = msg;
	}
	public Integer getCode() {
		return code;
	}
	public void setCode(Integer code) {
		this.code = code;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}
}
DataResult dr = DataResult.SUCCESS;
System.out.println(dr.name()); // SUCCESS
System.out.println(dr.msg); // 成功  应用，返回状态码
java中普通类，抽象类，接口的组成和关联（基础篇）
weixin_44720654的博客
09-24 940
拒绝八股文，用大白话让你读懂普通类/抽象类/接口 2.抽象类不能创建对象 用大白话解释一下：我们假设一下可以创建abstract（抽象类）对象，但是抽象方法没有具体的实现，是不是就没有存在的意义了！ 3.抽象类的方法理解 定义：没有具体的实现也就是{}（没有方法主体）
Java中常见的“类”大全
wwwwwmmn的博客
03-11 888
本文整理了常见的 Java 类目录，可跳转到指定函数进行详细学习。从基本数据类型的封装到复杂的数据结构和算法。用于表示字符串，提供了丰富的字符串操作方法，如拼接、分割、替换等。用于处理日期和时间，提供了日期和时间的各种操作方法。用于操作文件和目录，提供了文件和目录的各种操作方法。提供了各种数学计算方法，如绝对值、幂、平方根等。封装了对应的基本数据类型，提供了各种操作方法。提供了各种集合操作方法，如排序、查找、遍历等。
Java常用类
空白名Tee的博客
12-27 288
内部类 成员内部类 静态内部类 局部内部类 匿名内部类 什么是内部类 在一类的内部再定义一个完整的类 特点 编译之后可生成独立的字节码文件 内部类可直接访问外部类的私有成员，而不破坏封装 //身体 public class body { private String name = "空白"; //头部 class head{ public void show(){ System.out.println(name);
java 常用类
Java小菜鸟
03-10 457
1. 掌握Java的八种基本数据类型的包装类 八种数据类型： 包装类： 2. 理解Integer类的源码 Java中Integer是基本数据类型int的包装类。也就是每一个Integer对象包含一个int类型的属性，是抽象类Number类的子类，位于java.lang包下。 源码： public final class Integer extends Number implements Comparable<Integer> { @Native public stat.
普通的java类型是指,String是一个很普通的类 - Java那些事儿
weixin_34952710的博客
03-10 235
上一篇我们讲了Java中的数组，其实是为本章的内容做准备的，String这个类是我们在写Java代码中用得最多的一个类，没有之一，今天我们就讲讲它，我们打开String这个类的源码：声明了一个char[]数组，变量名value，声明了一个int类型的变量hash(hash的作用我们后续会讲)，话不多说，上代码：我们点开构造函数看一下：多年以前，我看到这段代码时我是懵逼的，没错，我现正在准备构造一个...
java普通类方法_java – 从普通类方法开始新活动
weixin_39819671的博客
02-27 168
我不知道如何在一个可以启动另一个活动的类中编写方法.我有一个带5个按钮的页脚,每个按钮都应该开始一个新的活动.我想用5个开始活动的方法创建一个类.我想做那样的事情：我的Footer_buttons课程：public class Footer_buttons{//Back to Home activitypublic static void home_footer(Context context) ...
Java常见类及其使用方法.md
03-29
Java常见类及其使用方法.md
Java常用类与基础API-String常见算法题目
04-07
Java常用类与基础API--String常见算法题目
自定义java常见工具类
04-18
java开发中常用的工具类 比如 1：hibernate的配置 工具类复写 2：字符串加密 MD5加密 3：javabean到map的自动映射封装 4：javabean java对象到xml的自动封装 5：各种日期格式的处理 6：json的自动封装处理 7：...
java常见面试题(史上最全最经典-希望对你有用)
11-12
在这里，我们总结了Java常见的面试题，涵盖了Java的基础部分，包括基本语法、类相关的语法、内部类的语法、继承相关的语法、异常的语法、线程的语法、集合的语法、IO的语法、虚拟机方面的语法等。 1. Java基础部分 ...
java普通类模拟枚举实现原理
chinoukin的博客
10-24 503
java类模拟枚举的实现原理，便于更好的理解枚举方式一/** * java普通类模拟枚举实现原理 * * @author chinoukin * */ public class WeekDay { private WeekDay() { } public final static WeekDay SUN = new WeekDay(); public fina
java 抽象类 普通类_java中抽象类与普通类、接口的区别分别是什么
weixin_36325174的博客
02-18 331
抽象类：一个类中有抽象方法，这个类就变成了抽象类。抽象类中class的前面必须有abstract修饰符。抽象类中可以有普通方法，也可以有抽象方法，而抽象方法的个数可以是0个，也可以是多个。子类继承父类，必须重写全部的抽象方法，除非这个类也变成了抽象类。免费在线学习视频推荐：java在线学习接口：表面上看，接口是一种特殊的抽象类，但是类是类，接口是接口，是并列的关系。接口中所有方法都必须是抽象的。(...
Java中抽象类和普通类的区别
最新发布
m0_46580983的博客
12-25 884
普通类（Concrete Class）普通类是Java中最基本的类，它可以被实例化，并且可以包含成员变量、方法和构造函数。普通类是面向对象编程的基础，允许开发者创建对象并定义对象的行为。抽象类（Abstract Class）抽象类是不能被实例化的类，它通常包含一个或多个抽象方法，这些方法没有实现，只定义了方法的签名。抽象类用于定义一个模板，子类必须实现抽象方法。抽象类也可以包含已实现的方法。
JAVA学习笔记第十三天——正则表达式、StringBuilder、包装类型、Collection常用API
guangjian_的博客
08-14 251
回顾: Object: 所有类的父类 getClass() -> 类加载, 字节码对象 clone() -> 深克隆和浅克隆 wait() * 3 notify() notifyAll() finalize() -> GC toString() equals() hashCode() Date: 时间- 年月日 时分秒 星期 时区 毫秒 new Date() - 当前系统时间 new Date(long time) - time毫秒所代表的时间 long getTime() void
Java基础——常用类
qq_52793248的博客
06-14 2290
Java基础——常用类
java普通类和抽象类区别
Flying_Fish_roe的博客
10-23 1095
普通类是Java中最基本的类，通常是一个完整的类，能够直接实例化。它包含完整的属性（成员变量）和方法，可以执行具体的操作。普通类可以实现接口，也可以继承自其他类。抽象类是一种特殊的类，不能直接实例化。它通常包含一个或多个抽象方法，这些方法没有实现（即方法体为空）。抽象类提供了一个类的框架或模板，子类必须实现抽象类中的抽象方法，才能创建具体的对象。抽象类可以包含已经实现的方法、抽象方法以及成员变量。普通类和抽象类在Java中扮演着不同的角色。普通类用于定义可以直接实例化的对象类型，它们包含具体的实现。
java笔记—— Java中类的类型
a25847a的博客
11-19 1118
抽象类是一种不能被实例化的类，它通常用于表示通用的概念，具体的实现交给其子类完成。接口是一个纯抽象的类，它只定义方法的签名（方法名、参数和返回值），不包含方法的具体实现。内部类可以访问外部类的成员变量和方法，它主要用于逻辑上和外部类关联的类。：用于封装外部类的复杂功能，可以访问外部类的成员，适合封装与外部类紧密相关的逻辑，增强代码的封装性。：用于定义行为规范，特别适合需要实现多种行为的类，通过接口实现多继承，增强了代码的灵活性。作用：接口定义类应该具备的行为，但不提供具体的实现，主要用于规范类的行为。
JAVA基础篇——类
weixin_48589156的博客
05-27 1702
Java的重要概念之一类 一、类的定义 定义 类：类是一个模板（本质是一种数据类型，若对C语言有所了解可简单理解成struct结构体，区别在于Java的类可包含方法，而结构体没有），它描述一类对象的行为和状态。 对象：对象是类的一个实例（这里的对象不是女朋友），有状态和行为。例如，狗是一个这个名词是一个类的概念，你家喂养的旺财就是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。 类的使用 1.定义类语法格式 ： [final] [public] class 类名 { 成员； 构造方
Java 抽象类、普通类、接口的区别——值得你一看的干货
热门推荐
csdn_aiyang的博客
05-04 4万+
且不说会有很多人合作一起写一个程序，哪怕还是你一个人写，也保不住有忘记的时候，那时候编译器不报错，茫茫码海上哪找错误去面向对象说到底就是方便你思考，易扩展、易维护管理，硬要说没必要，整个面向对象都没必要了，C语言有什么干不了的呀，运行效率还高。抽象的概念是由具体概念依其“共性”而产生的，把具体概念的诸多个性排出，集中描述其共性，就会产生一个抽象性的概念。所以，在高级语言上，一个类只能继承一个类或抽象类，正如人不可能同时是动物类又是植物类，但是可以实现多个接口，例如，吃饭接口、呼吸接口等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值