Javase-day12-Object类，日期相关类，System类，StringBuilder类，包装类

最新推荐文章于 2024-04-28 11:31:41 发布
最新推荐文章于 2024-04-28 11:31:41 发布
阅读量706 收藏 1
点赞数 1
分类专栏： # Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44216110/article/details/105870867
版权

文章目录

一、Object类

回到目录

1.1 概述

java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类， 那么默认则继承自Object类。例如：

public class MyClass /*extends Object*/ {
  	// ...
}

Object类当中包含的方法有11个(JDK9)，这里主要介绍toString和equals方法

1.2 toString方法

方法摘要

  • public String toString()：返回该对象的字符串表示。
    作用：打印对象信息

toString方法返回该对象的字符串表示，其实该字符串内容就是【包名类名+@+内存地址值】。
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

  • 重写前：打印的是【包名类名@地址值】
  • 重写后：打印的是【对象中的属性值】（成员变量的值）
Student类：
public class Student /*extends Object*/{
    private String name;
    private int age;

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

    public Student() {
    }

    @Override		// 可以快捷键重写toString方法
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", 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 class Test01 {
    public static void main(String[] args) {
        String str = "abc";
        System.out.println(str/*toString()*/); // 显示的是 abc
        // str 相当于 str.toString()
        // 因为在 String 类当中，已经重写了toString方法，可以直接打印出字符串

        Student s = new Student("张三",23);
        // 没在Student类中重写toString方法时
        System.out.println(s/*toString()*/);    // 显示的是 包名@b4c966a
        System.out.println(s.toString());       // 显示的是 包名@b4c966a

        // 在Student类中重写toString方法后（IDEA直接快捷键生成重写的toString）
        System.out.println(s);         // 显示：Student{name='张三', age='23'}
    }
}

1.3 equals方法

方法摘要

  • public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
    作用：比较两个对象

  • 重写前：比较的是两个对象的地址值

  • 重写后：比较对象中的属性值（成员变量）

Student类：
import java.util.Objects;	// 注意，重写了equals方法，就会导入这个包

public class Student /*extends Object*/{
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override		// 重写toString方法
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    @Override		// 重写equals方法
    public boolean equals(Object o) {
    	// 比较地址是否相同
        if (this == o) return true;
        
        // 判断参数是否为null, 判断两个对象是否来自于同一个类
        if (o == null || getClass() != o.getClass()) return false;
        // 向下转型
        Student student = (Student) o;
        // 比较内容是否相同
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    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 class Test02 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
		// String类里面，已经重写了equals方法，直接比较对象的属性值，而非地址值
        System.out.println(s1.equals(s2));  // true

        Student stu1 = new Student("张三",23);
        Student stu2 = new Student("张三",23);
        // 在重写 Students 类的 equals 方法之前,比较的是二者的地址值
        System.out.println(stu1.equals(stu2));  // false

        // 快捷键,重写 Students 类的 equals 方法之后,比较的是二者的属性值.
        // 认为同姓名同年龄的就是同一个人
        System.out.println(stu1.equals(stu2));  // true
    }
}

二、Objects类中的equals方法

回到目录
Objects类中的equals方法：比较两个对象是否相同，但是加了一些健壮性的判断。

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类(要导包)。Objects类是对象的工具类。

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

  • public static boolean equals(Object a, Object b):判断两个对象是否相等。
import java.util.Objects;

public class Test03 {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = "abc";

//      System.out.println(s1.equals(s2));  // 将产生空指针异常,NullPointerException

        boolean result = Objects.equals(s1,s2);
        System.out.println(result);         // 显示的是 false
    }
}

三、日期相关类

回到目录

3.1 Date类

java.util.Date类 表示特定的瞬间，精确到毫秒。

  • 构造方法：
Date(); : 根据当前系统时间创建日期对象

Date(long time); : 根据传入的毫秒值创建日期对象
  • 成员方法
long getTime(); : 获取当前日期对象的毫秒值时间

String toLocaleString(); : 根据本地格式转换日期对象

import java.util.Date;

public class Test01 {
    public static void main(String[] args) {
        // 空参构造方法
        Date d1 = new Date();
        System.out.println(d1);      // Sat May 02 08:56:51 CST 2020
        System.out.println(d1.toLocaleString()); // 本地时间的格式：2020年5月2日 上午8:56:51

        Date d2 = new Date(3000L);  // 3000毫秒. long类型的构造参数, 可以指定毫秒数
        System.out.println(d2.toLocaleString()); // 1970年1月1日 上午8:00:03
        // 计算机时间原点是1970年1月1号0点0分0秒，中国是东八区，所以是8点0分0秒

    }
}

3.2 DateFormat类和SimpleDateFormat类

 　由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。SimpleDateFormat类:

  • 构造方法
    SimpleDateFormat(String s); 根据指定模板创建日期格式化对象
  • 成员方法
    String format(Date d); 根据指定格式格式化日期对象
    Date parse(String s); 根据指定格式解析字符串

格式规则

常用的格式规则为：

标识字母（区分大小写）含义
y年
M月
d日
H时
m分
s秒

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档0。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test01 {
    public static void main(String[] args) throws ParseException {
        // 空参构造方法
        Date d1 = new Date();
        System.out.println(d1);      			 // Sat May 02 08:56:51 CST 2020
        System.out.println(d1.toLocaleString()); // 本地时间的格式：2020年5月2日 上午8:56:51
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String format = sdf.format(d1);		// 利用SimpleDateFormat类中的format方法，按照sdf的格式，格式化日期显示
        System.out.println(format);			// 2020年05月02日 09:17:04
		
		String str = "2088年08月08日 08:08:08";
        Date parse = sdf.parse(str);    	// 要抛出异常。将字符串类型日期按找sdf的格式进行解析，解析为一个日期对象
        System.out.println(parse);			// Sun Aug 08 08:08:08 CST 2088
    }
}

3.3 Calendar类

java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。
Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时不能直接创建，而是通过要通过其静态方法创建，返回子类对象，如下：

  • 创建对象方式（比较特殊）
Calendar c = Calendar.getInstance();		// 根据日历类创建一个对象, 类名.静态方法名(参数列表);
  • 成员方法
int get(int n);								获取指定日历字段信息
void set(int n, int value);					将指定日历字段设置为指定的字段值

void add(int n, int value);					将指定日历字段增加或减少指定的值

Date getTime();								返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的【Date对象】
											Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象

Calendar类中提供很多成员常量，代表给定的日历字段：

字段值含义
YEAR年
MONTH月（从0开始，可以+1使用）
DAY_OF_MONTH月中的天（几号）
HOUR时（12小时制）
HOUR_OF_DAY时（24小时制）
MINUTE分
SECOND秒
DAY_OF_WEEK周中的天（周几，周日为1，可以-1使用）
import java.util.Calendar;
import java.util.Date;

public class Test03 {
    public static void main(String[] args) {
        // 获取日历类对象
        Calendar c = Calendar.getInstance();

        // get方法
        int year = c.get(Calendar.YEAR);
        System.out.println(year);    // 2020

        int month = c.get(Calendar.MONTH)+1;    //国外的月份从0开始，要加1 ？
        System.out.println(month);  // 5

        // set方法
        c.set(Calendar.YEAR,2088);
        year = c.get(Calendar.YEAR);
        System.out.println(year);   // 2088

        // add方法
        c.add(Calendar.YEAR,2);
        year = c.get(Calendar.YEAR);
        System.out.println(year);   // 2090

        c.add(Calendar.YEAR,-2);
        year = c.get(Calendar.YEAR);
        System.out.println(year);   // 2086

		Calendar cal = Calendar.getInstance();	// 创建了一个对象，对象名为cal
        Date date = cal.getTime();				// 拿到对应的Date对象，地址是date
        System.out.println(date);				// 打印出实际的时间：Sat May 02 09:59:36 CST 2020
    }
}

四、 System类

回到目录
java.lang.System类中提供了大量的静态方法，常用的方法有：

  • public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
  • public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

4.1 currentTimeMillis()方法

实际上，currentTimeMillis()方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值（中国东八区是8点）。

练习：验证for循环打印数字1-9999所需要使用的时间（毫秒）

public class SystemTest1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();	// 起始时间
        for (int i = 0; i < 10000; i++) {
            System.out.print(i + " ");
        }
        long end = System.currentTimeMillis();		// 打印好了的时间
        System.out.println("共耗时毫秒：" + (end - start));
    }
}

4.2 arraycopy()方法

  • public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

参数序号参数名称参数类型参数含义
1srcObject源数组
2srcPosint源数组索引起始位置
3destObject目标数组
4destPosint目标数组索引起始位置
5lengthint复制元素个数
arraycopy(int[] src, int srcIndex, int[] dest, int destIndex, int count)参数列表解释:
int[] src —— 要拷贝的数组；	int srcIndex —— 从数组的第几位开始拷贝；		
int[] dest —— 要接收的数组；		int destIndex —— 从要接收数组的第几位开始接收；	int count —— 接收几个

示例：

public class Test1 {
    public static void main(String[] args) {
        // 获取一下当前系统毫秒值时间
        long time = System.currentTimeMillis();
        System.out.println(time);   // 距离计算机时间原点的毫秒数    1588389810888

        // arraycopy(int[] src, int srcIndex, int[] dest, int destIndex, int count)拷贝数组
        int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] arr2 = {9, 8, 7, 6, 5, 4, 3, 2, 1};
        // 将 arr1 数组中的前四个数字拷贝到 arr2 数组中
        System.arraycopy(arr1, 0, arr2, 0, 4); // 是直接替换掉前四个！

        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");    // 1 2 3 4 5 4 3 2 1
            // 直接将 arr2 数组的前四个数给替换掉了
        }
    }
}

五、StringBuilder类

回到目录
 　String类的对象创建后就不可以改变（字符串是常量，它们的值在创建后不能被更改）。所以每当进行字符串拼接时，总是会在内存中创建一个新的String对象。每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为解决这一问题，可使用java.lang.StringBuilder类。
 　StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

StringBuilder类的原理如下图所示：(默认16字符空间，超过自动扩充)
在这里插入图片描述

5.1 StringBuilder类的常用构造方法

  • public StringBuilder()：构造一个空的StringBuilder容器。
  • public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。
public class StringBuilderDemo {
    public static void main(String[] args) {
    	// 使用无参构造
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); 		// 打印出来的是空白
        
        // 使用有参构造
        StringBuilder sb2 = new StringBuilder("aabbcc");
        System.out.println(sb2); 		// aabbcc
    }
}

5.2 StringBuilder类的常用方法

  • public StringBuilder append(...)：添加任意类型数据的字符串形式，返回的还是当前对象本身。
  • public StringBuilder reverse()：反转所有内容，注意返回的还是对象自己。
  • public String toString()：将当前StringBuilder对象转换为String对象。

String对象与StringBuilder对象的相互转化

  • 由String对象转化为StringBuilder对象：用StringBuilder类的有参构造方法
  • 由StringBuilder对象转化为String对象：用StringBuilder类中重写过的toString方法

5.2.1 append方法

append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder对象中。
例如：

public class Demo02StringBuilder {
	public static void main(String[] args) {
		//创建对象
		StringBuilder builder1 = new StringBuilder();
		//public StringBuilder append(任意类型)
		StringBuilder builder2 = builder1.append("hello");	
		// StringBuilder类中的append方法，返回的还是builder1，即builder1和builder2是一摸一样的
		System.out.println("builder:" + builder1);	// hello
		System.out.println("builder2:" + builder2);	// hello
		System.out.println(builder1 == builder2); 	// true		append方法返回的还是对象自身
		
	    // append方法的参数列表中可以添加 任何类型
		builder1.append("hello");
		builder1.append("world");
		builder1.append(true);
		builder1.append(100);
		// 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
        // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
		//链式编程
		builder1.append("hello").append("world").append(true).append(100);
		System.out.println("builder:"+builder1);
	}
}

5.2.2 reverse方法

public StringBuilder reverse()：反转内容，注意返回的还是对象自己。

public class Test2 {
    public static void main(String[] args) {
        
        StringBuilder sb = new StringBuilder();
        sb.append("Hello, ").append("World ").append("Java ").append(1234);
        // append()方法的链式写法
        System.out.println(sb);     // Hello, World Java 1234

        sb.reverse();
        System.out.println(sb);     // 4321 avaJ dlroW ,olleH
    }
}

5.2.3 toString方法

备注：StringBuilder类中已经重写了Object类中的toString方法。

通过toString方法，StringBuilder对象将会被转换为不可变的String对象（将缓冲区内容转换为字符串数据）。如：

public class Demo16StringBuilder {
    public static void main(String[] args) {
        // 链式创建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 调用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

六、包装类

回到目录
 　Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型对应的包装类（位于java.lang包中）
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

6.1 自动拆装箱

  • 装箱：从基本类型转换为对应的包装类对象。
  • 拆箱：从包装类对象转换为对应的基本类型。

从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。

Integer i = 4;		// 自动装箱，相当于Integer i = Integer.valueOf(4);

i = i + 5;			// 等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
					// 加法运算完成后，再次装箱，把基本数值转成对象。

6.2 基本类型与字符串类型的相互转换

6.2.1 基本类型转换为String类型

  • 基本类型的值 + “” ; 这是最简单的方法(最常用)；
int i1 = 100;
String s1 = i1+"";			// 这样，s1就是字符串100了
System.out.println(s1+200);	//100200		字符串100加上数字200，先将数字转换为字符串，再用字符串的拼接
  • 使用【包装类】（java.lang包）中的静态方法toString(参数),不是Object类的toString() 重载；
static String toString(int i) 返回一个表示指定整数的 String 对象
  • String类的静态方法valueOf(参数)
static String valueOf(int i) 返回 int 参数的字符串表示形式。

示例：

方法2：
String s2 = Integer.toString(100);
System.out.println(s2+200);		//100200

方法3：
String s3 = String.valueOf(100);
System.out.println(s3+200);		//100200

6.2.2 String类型转换为对应的基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

  • public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
  • public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
  • public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
  • public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
  • public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
  • public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：

public class Demo18WrapperParse {
    public static void main(String[] args) {
        int num = Integer.parseInt("100");		// 静态方法，直接用类名称.静态方法就行
    }
}

注意: 如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常（数字格式化异常）。

例如：	int a = Integer.parseInt("a");			// NumberFormatException	数字格式化异常
流星小羽
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JavaSE------Object类，常用类
qq_45370568的博客
04-04 127
Object类 Date类 DateFormat类 Calendar类 System类 StringBuilder类 包装类 第一章 Object类1.1 概述java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。 如果一个类没有特别指定父类， ...
JavaSE----之三个特殊的类
sister的博客
11-10 189
JavaSE----之三个特殊的类 String 类 Object类 包装类 1. java . lang.String 类 1.1 String 类的两种实例化方式 直接赋值（在堆上分配空间） String str = “hello”; //str 是一个对象，指向堆内存“hello” String 本身是一个类，因此存在构造方法，如下： public String（Strin...
【15】JAVASE-常用工具类【从零开始学JAVA】
最新发布
波波烤鸭的博客
04-28 798
从零开始学Java系列课程
JavaSE-JDK常用类-包装类、字符串相关类
feicongcong的博客
03-16 150
1.String 类 1.1 String 类 public final class String implements java.io.Serializable, Comparable<String>, CharSequence { /** The value is used for character storage. */ private final char value[]; ...
[JavaSE-11]Object类和常用的API
学哥斌的博客
01-08 179
1、Object类   java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。如果一个类没有特别指定父类， 那么默认则继承自Object类。   根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。最常用的是toSting和equals这两个方法 1.1 toSt...
JavaSE---08常用类
feverd555的博客
05-21 491
02 常用类 2.1 字符串相关的类 String 2.1.1 String类的概述 String:字符串，使用一对“”引起来表示。 String声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。 实现了Comparable接口：表示String可以比较大小 String内部定义了final char[] value用于存储字符串数据 String:代表不可变的字符序列。简称：不可变性。 体现： 当对字符串重新赋值时，需要重写指定内
Day19.常用类：String类、正则表达式、StringBuffer、包装类、System系统相关类
a111042555的博客
12-30 419
JavaSE基础 常用类
JavaSE---常用类
qq_44125413的博客
01-28 335
JAVAAPI概述 API(Application Programming Interface)应用程序编程接口 是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明. API—>语言中提供的类,接口 API–>对类,接口功能的说明文档 基本数据类型包装类 基本类型：结构简单 int short long byte char boolean double float 每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类.
不快乐爪洼_JavaSE_常用类
nuo
07-21 582
JavaSE_常用类
J003-JavaSE-RevE.1.1.pdf
07-30
2. java.lang包：这个包是Java编程语言的核心包，它包含了许多基础和必须的类，例如String、Integer、Float等封装基本数据类型的包装类（Wrapper），以及Math类，后者提供了基本的数学函数如求最大值、生成随机数等...
8、JavaSE：常用类.pdf
04-24
与String紧密相关的扩展类StringBuilder和StringBuffer也将在本阶段被探讨，这两个类都是用于可变字符序列的，但StringBuffer是线程安全的，而StringBuilder则在多线程环境下表现更好。 包装类（Wrapper classes）...
JavaSE-day03-Lambda
simpleness
10-24 268
1. Static关键字 概述 1. 使用static关键字修饰的内容,属于类,不在属于对象或者方法.凡是创建的本类对象,都共享static修饰的成员变量,或者方法 修饰成员变量、成员方法 1. 如果一个成员变量使用static关键字修饰,那么这个成员变量不在属于对象自己,而是属于所在类,多个对象共享同一份数据 2. 如果一个成员方法使用static修饰,那么就成了静态方法,静态方法不属于对象,而属于类 注意: 如果没有static修饰,那么必须先创建对象,然后通过对象来使用 使用static修饰的
Javase-day17-线程
流星的博客
05-26 784
文章目录一、多线程1、并发与并行2、进程与线程3、多线程的实现程序3.1 **创建多线程方式一：** 定义一个子类继承Thread类，这个子类应该重写Thread类的run方法3.2 设置和获取线程名称3.3 线程调度 一、多线程 1、并发与并行 并发： 两个或多个事件在同一时间段内发生（交替执行）； 并行： 两个或多个事件在同一时间段内发生（同时运行）； 它们虽然都说是"多个进程同时运行"，但是它们的"同时"不是一个概念： 并发的"同时"是经过上下文快速切换，使得看上去多个进程同时都在运行的现象，是一种
Javase-day20-网络流编程
流星的博客
05-31 688
Java网络编程
Javase-day13-Collection集合、Iterator迭代器、泛型
流星的博客
04-30 518
一、Collection集合
Javase-day23-Junit单元测试、反射、注解
流星的博客
06-17 472
Junit单元测试、反射、注解
Javase-day11-final关键字，四种权限修饰符，内部类
流星的博客
04-30 470
一、final关键字 1、final关键字的概念 final关键字代表最终、不可改变的 2、final关键字的四种常用用法 可以用来修饰一个类； 可以用来修饰一个成员方法； 可以用来修饰一个局部变量； 可以用来修饰一个成员变量。 2.1 final关键字用于修饰类 当final关键字用来修饰一个类的时候，不能使用final类来作为父类。 final 修饰类的格式： public final c...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值