java的类是什么

java的类是什么？让我们一起了解一下吧！

java中的类就是具备某些共同特征的实体的集合，它是一种抽象的数据类型，是对所有具有相同特征实体的抽象。在面向对象的程序设计语言中，类是对一类“事物”的属性与行为的抽象。

拓展：一个类可以包含的类型变量

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

java的类是什么意思

Java常用类，这一次帮你总结好

常用类常用类概述：

1. 内部类
2. Object类
3. 包装类
4. 数学类
5. 时间类
6. 字符串
7. String Builder和StringBuffer
8. DecimalFormat

概念：在一个类内部再定义一个完整的类。

一般情况下类与类之间是相互独立的，内部类的意思就是打破这种独立思想，让一个类成为另一个类的内部信息，和成员变量、成员方法同等级别。

把一个类写在外面和写在里面最终达到的结果都一样，那我们为什么还要使用内部类，岂不是多此一举吗？

【参考代码】

package NeiBuLei;public class OuterClass { //成员变量 private String OuterName; //成员方法 public void display(){ System.out.println("这是外部类方法！"); System.out.println(OuterName); } //内部类 public class InnerClass{ //成员变量 private String InnerNme; //构造方法 public InnerClass() { InnerNme = "Inner Class"; } //成员方法 public void display(){ System.out.println("这是内部类方法！"); System.out.println(InnerNme); } } // 主方法 public static void main(String[] args) { OuterClass outerClass = new OuterClass(); outerClass.display();//这是外部类方法！ null // 这个类是内部类，已经不是独立的类了，因此不能像外部类一样直接创建！ //InnerClass innerClass = new InnerClass(); 行不通 OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成员方法/变量 只是加了个前缀 innerClass.display();// 这是内部类方法！ }}

输出结果：

这是外部类方法！

null

这是内部类方法！

Inner Class

局部内部类：基本的内部类还可以在一个方法体中定义。

package NeiBuLei;public class OuterClass { //成员变量 private String OuterName; //成员方法 public void display(){ class InnerClass { public void print(){ System.out.println("这是一个局部内部类方法！"); } } InnerClass innerClass = new InnerClass(); innerClass.print(); } // 主方法 public static void main(String[] args) { OuterClass outerClass = new OuterClass(); outerClass.display(); }}3.静态内部类

静态内部类的构造不需要依赖于外部类对象，类中的静态组件都不需要依赖于任何对象，可以直接通过 类本身 进行构造。

package NeiBuLei;public class OuterClass { //成员变量 private String OuterName; //成员方法 public void display(){ System.out.println("这是外部类方法！"); System.out.println(OuterName); } //静态内部类 public static class InnerClass{ private String InnerName; public InnerClass() { InnerName = "Inner Class"; } //成员方法 public void display(){ System.out.println("这是静态内部类方法！"); System.out.println(InnerName); } } // 主方法 public static void main(String[] args) { OuterClass outerClass = new OuterClass(); outerClass.display(); // 静态内部类的构造不依赖与外部类，可以直接通过类本身进行构造！ InnerClass innerClass = new InnerClass(); innerClass.display(); }}

输出结果：

这是外部类方法！

null

这是静态内部类方法！

Inner Class

匿名内部类：没有名字的内部类。

匿名内部类 主要应用与接口的实现！

接口：

package NeiBuLei;public interface MyInterface { public void test();}

实现类：

package NeiBuLei;public class MyImplement implements MyInterface{ @Override public void test() { System.out.println("test"); }}

匿名内部类的使用：

package NeiBuLei;public class Test { public static void main(String[] args) { //实现类 MyInterface myInterface = new MyImplement(); myInterface.test(); //匿名内部类 MyInterface myInterface1 = new MyInterface() { // 接口是不能new的，这里new的是接口的实现类（和实现类是一样的（同一个东西）,没有实例而已） @Override public void test() { System.out.println("test"); } }; myInterface.test(); /** * 最终两种实现方式的结果都是一样的！ */ }}匿名内部类的好处：

我们定义接口之后， 它的实现类不需要去单独创建一个文件去写它的实现 ，我们可以把这个实现类的操作写到我们调用的地方就可以了！写起来更加简洁、方便。

耦合度太高了！

Jdk中文在线文档： Java 8 中文版 - 在线API中文手册 - 码工具 (matools.com)

==是一个比较运算符

1. ==： 既可以判断基本类型，又可以判断引用类型
2. ==： 如果判断的是 基本类型 ， 判断的是值是否相等 。//==： 如果判断的是基本类型，判断的是 值 是否相等 int x1 = 10; int x2 = 10; double x3 = 10.0; System.out.println(x1 == x2);//true System.out.println(x1 == x3);//true
3. ==： 如果判断的是 引用类型 ， 判断的是地址是否相等，即判断是不是同一个对象package Equals; public class Test01 { public static void main(String[] args) { //==： 如果判断的是引用类型，判断的是地址是否相等，即判断是不是同一个对象 A a = new A(); A b = a; A c = b; System.out.println(a==c);// ? true System.out.println(b==c);// true B obj = a; System.out.println(obj==c);// true } } class B{} class A extends B{}

4. equals方法是Object类中的方法， 只能判断引用类型 。

idea查看jdk原码：鼠标光标放在要查看的方法上，直接输入 ctrl b

查看某个类所有方法： ctrl F12

5. 默认判断的是地址是否相等， 子类(Object类是所有类的父类)往往重写该方法，用于判断内容是否相等 。

/*Object类 equals()方法原码//默认判断地址是否一样 public Boolean equals(Object obj) { return (this == obj); } 子类往往重写该方法，用于判断内容是否相等 String类中的equals()方法原码（重写了父类equals()方法） public boolean equals(Object anObject) { if (this == anObject) { // 如果是同一个对象(地址相同) return true; // 返回true } if (anObject instanceof String) { // 判断类型 String anotherString = (String)anObject; // 向下转型 int n = value.length; if (n == anotherString.value.length) { // 如果长度相同 char v1[] = value; char v2[] = anotherString.value; int i = 0; while (n-- != 0) { // 比较每一个字符 if (v1[i] != v2[i]) return false; i ; } return true; // 如果两个字符串每一个字符都相同，则返回true } } return false; } */

在看个例子

【小练习】

写出输出结果：

package Equals;public class EqualsTest01 { public static void main(String[] args) { Person p1 = new Person(); p1.name = "tom"; Person p2 = new Person(); p2.name = "tom"; System.out.println(p1 == p2);// 引用类型——判断是否为同一个对象（地址） System.out.println(p1.name.equals(p2.name));// p.name是String类型，重写了equals()方法——判断内容是否一样 System.out.println(p1.equals(p2));//p1,p2属于Person类，该类并没有重写equals()方法（继承父类equals()方法，即判断地址） String s1 = new String("abc"); String s2 = new String("abc"); System.out.println(s1.equals(s2)); System.out.println(s1 == s2); }}class Person{ public String name;}

输出结果：

false

true

false

true

false

小结：（可以当作地址来看但它本质上不是地址）

1. 提高具有哈希结构的容器的效率
2. 两个引用，如果指向的是同一个对象，则哈希值肯定一样
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
4. 哈希值主要根据地址号来！不能将哈希值完全等价于地址
5. 在后面的集合中hashCode如果需要的话，也会重写

package hashCode;public class HashCode { public static void main(String[] args) { AA aa = new AA(); AA aa2 = new AA(); AA aa3 = aa; System.out.println("aa.hashCode()=" aa.hashCode()); System.out.println("aa2.hashCode()=" aa2.hashCode()); System.out.println("aa3.hashCode()=" aa3.hashCode()); }}class AA{}

aa.hashCode()=460141958 aa2.hashCode()=1163157884 aa3.hashCode()=4601419583.toString方法

基本介绍：

默认返回：全类名 @ 哈希值的十六进制

/* Object toString()原码 //(1)getClass().getName() 类的全类名（包名 类名） //(2)Integer.toHexString(hashCode()) 将hashCode的值转成16进制字符串 public String toString() { return getClass().getName() "@" Integer.toHexString(hashCode()); } */

当我们输出一个对象时，toString()方法会被默认调用

finzlize方法：当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。

1. 当对象被回收时，系统自动调用该对象的finzlize方法。子类可以重写该方法，做一些释放资源的操作
2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会时候垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finzlize方法。

3. 垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制。

注：在实际开发中，几乎不会用finzlize方法，更多的是为了应付面试

byte -> Byte

short -> Short

int -> Integer

long -> Long

float -> Float

double -> Double

char -> Character

boolean -> Boolean

这些类都在java.lang包

1. 让基本数据类型有面向对象的特征
2. 封装了字符串转化成基本数据类型的方法（重点）

1. Integer.parseInt()
2. long.paseLong()
3. Double.parseDouble()

【参考代码】

public class Test { public static void main(String[] args) { // Integer i = new Integer(10);// 创建包装类对象// Integer ii = 10; // 自动打包// System.out.println(i 10); // 在使用上，int 和Integer 其实没有区别，可以互相使用// System.out.println(ii 10);// int j = ii;// 自动解包// System.out.println(j 100); String a = "12"; String b = "34"; System.out.println(a b); // 1234 // 转型: // 字符串转成int的唯一方案 int c = Integer.parseInt(a); int d = Integer.parseInt(b); System.out.println(c d); // 46 // 字符串转成double类型 String e = "1.25"; double f = Double.parseDouble(e); System.out.println(f*6); // 7.5 // 转成long类型 long l = Long.parseLong("1234567"); System.out.println(l); }}四、数学类

数学类的方法都是静态方法，可以直接引用——Math.方法();

1. abs()：获取绝对值
2. max()：求最大值
3. min()：求最小值
4. pow()：求次幂
5. round()：四舍五入
6. sqrt()：求平方根

1. Date 日期类
2. Calendar 日历类
3. SimpleDateFormat 格式化时间类

Date和Calendar类 在java.util包中SimpleDateFormat类 在java.text包1.Date 日期

【1】new Date() 可以获取到系统时间

【2】getTime() 能获取到时间的long形式，可以用来计算时间差

getTime()——获取计算机底层存储的数字，返回一个数字用来表示时间，这个数字的类型long，单位为毫秒。

【参考代码】

import java.util.Date;public class Test { public static void main(String[] args) { Date d = new Date(); System.out.println(d); // 系统时间 //get...()——获取年月日..... System.out.println(d.getYear() 1900); // 从1900年开始算的 System.out.println(d.getMonth() 1); // 月份从0开始计算 System.out.println(d.getDate()); // 天数 System.out.println(d.getHours());// 小时 //getTime()——获取到时间的毫秒形式 返回的是long System.out.println(d.getTime()); }}2.Calendar 日历

【1】get() 获取到时间的某一部分

【2】set() 设置时间 - -> 计算时间：系统已经帮我们设置好了，不用担心二月有多少天等问题，计算时间十分方便

注：Calendar 日历类是抽象类，因此不可以去new对象。虽然抽象类不能创建对象，但是jdk官方提供了一个实例对象的操作：

Calendar rightNow = Calendar.getInstance();

我们通过这条代码就是直接造了一个Calender的对象

【参考代码】：get() 获取到时间的某一部分：

package date;import java.util.Calendar;public class TestCalendar { public static void main(String[] args) { Calendar cal = Calendar.getInstance();// System.out.println(cal); /* 假设当天： 2021 8 10 */ cal.set(Calendar.DATE,cal.get(Calendar.DATE) 31); // 计算时间(这里用天数计算的) // 获取Calendar创建的对象里的所有内容 System.out.println(cal.get(Calendar.YEAR)); // 2021 年 System.out.println(cal.get(Calendar.MONTH) 1); // 月份：从0开始的 结果：为10月 System.out.println(cal.get(Calendar.DATE)); // 日 System.out.println(cal.get(Calendar.HOUR_OF_DAY));// 小时 System.out.println(cal.get(Calendar.MINUTE)); System.out.println(cal.get(Calendar.SECOND)); }}

【参考代码】：set() 设置时间 - -> 计算时间：

注：cal.setTime(d); 把Date转化成Calendar

package date;import java.util.Calendar;import java.util.Date;public class TestCalendar { public static void main(String[] args) { Date d = new Date(); Calendar cal = Calendar.getInstance(); cal.setTime(d);// 把Date转化成Calendar System.out.println(cal); System.out.println(cal.get(Calendar.YEAR)); // 年 System.out.println(cal.get(Calendar.MONTH) 1); // 月份：从0开始的 System.out.println(cal.get(Calendar.DATE)); // 日 }}3.SimpleDateFormat格式化时间

Date，Calendar通过引用也可以进行时间的格式化，但比较繁琐，而SimpleDateFormat类是专门帮我们格式化时间的工具类，它在java.text包中。

【时间格式】：yyyy-MM-dd HH:mm:ss

SimpleDateFormat类有两大常用方法：

【1】format(Date)：

format(Date) 帮我们把时间转成字符串，字符串的格式为SimpleDateFormat类定义对象时设置的时间格式

【参考代码】

package Simple;import java.text.SimpleDateFormat;import java.util.Date;import java.util.logging.SimpleFormatter;public class Test { public static void main(String[] args) { Date d = new Date(); System.out.println(d); //Thu Aug 12 08:40:08 CST 2021 不美观 // 设置格式化时间的模式，我们常用yyyy-MM-dd HH:mm:ss这个模式 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 时间格式 String s = sdf.format(d); // 格式化时间 System.out.println(s); // 2021-08-12 08:45:09 }}

【2】parse(String)：

parse(String) 帮我们把字符串转化成时间

【参考代码】

package Simple;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Scanner;public class Test2 { public static void main(String[] args) throws ParseException { Scanner sc = new Scanner(System.in); System.out.println("请输入一个时间(yyyy-MM-dd HH:mm:ss)："); String s = sc.nextLine(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date d = sdf.parse(s); // 把字符串转成时间 System.out.println(d); /* 请输入一个时间(yyyy-MM-dd HH:mm:ss)： 2021-08-12 12:25:21 Thu Aug 12 12:25:21 CST 2021 */ }}

注：由于用户输入的字符串不一定是我们要求的格式，可能是任何东西，想把它们转成时间是不可能的，你不可能把一个人转成时间 对吧，因此存在着很大的风险未处理(异常: java.text.ParseException)，为此我们需要处理异常。

计算思路：

1. 格式化时间
2. 先将字符串转化成long类型时间
3. 计算毫秒级别时间差，取绝对值
4. 毫秒级别时间差转成秒级别
5. 秒级别时间差转成分钟级别
6. 分钟级别时间差转化显示成xx小时xx分钟

【参考代码】

package Simple;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;public class TestDiff { public static void main(String[] args) throws ParseException { String s1 = "2021-08-12 12:00:00"; // 开始时间 String s2 = "2021-08-12 14:35:00"; // 结束时间 //格式化时间 SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss"); //将字符串转成时间形式 Date d1 = sdf.parse(s1); Date d2 = sdf.parse(s2); //计算时间差:先要获取时间毫秒形式（long类型） 再做差 long long1 = d1.getTime(); long long2 = d2.getTime(); long diffTime = Math.abs(long1 - long2); // 秒级别时间差 long diffSec = diffTime / 1000; // 分级别时间差 long diffMin = diffSec / 60; //显示 xx小时xx分钟 long displayHours = diffMin / 60; // 小时 long displayMin = diffMin % 60; //分钟 System.out.println("您学习的时长为：" displayHours "小时" displayMin "分钟"); }}六、String类字符串类常用方法方法汇总：

【示例代码】

public class Test { public static void main(String[] args) { String s = "我的名字叫李华"; s.concat("hhh"); // 在字符串s上拼接，拼接hhh System.out.println(s);// 我的名字叫李华 //字符串是不可变的数据类型 //几乎所有的字符串操作都会返回一个新字符串 String s1 = s.concat("hhh"); // 在字符串s上拼接，拼接hhh System.out.println(s1);//我的名字叫李华hhh String str1 = "李华喜欢看罗老师的视频"; str1.replace("李华","张三"); System.out.println(str3); //李华喜欢看罗老师的视频 并没有替换 字符串是不变的str1还是str1 String str2 = str1.replace("李华","张三");//几乎所有的字符串操作都会返回一个新字符串 新串要用新变量接 System.out.println(str2);//张三喜欢看罗老师的视频 }}

package String;import java.util.Scanner;public class Test { public static void main(String[] args) { String s = "我的名字叫李华"; System.out.println(s.charAt(0)); // 获取第0个位置的字符 s.concat("hhh"); System.out.println(s);// 我的名字叫李华 //字符串是不可变的数据类型 //几乎所有的字符串操作都会返回一个新字符串 String s1 = s.concat("hhh"); // 在字符串s上拼接，拼接hhh System.out.println(s1);//我的名字叫李华hhh System.out.println(s.contains("李华")); //true System.out.println(s.contains("牛津")); //false System.out.println("邀请李华来参加英语沙龙活动".endsWith("活动"));//true 判断是否以xxx为结尾 System.out.println("邀请李华来参加英语沙龙活动".startsWith("李华"));//false 判断是否以xxx开头 // equals字符串内容是否相同 // 接受邀请参加活动的李华到现场后要输入验证码// String yanZhengMa = "AAkm";//// Scanner sc = new Scanner(System.in);//// System.out.println("请输入验证码(" yanZhengMa ")");//// String userInput = sc.nextLine();//// if(yanZhengMa.equalsIgnoreCase("aakm")){ // 忽略大小写判断两边的内容是否一样// System.out.println("欢迎参加英语沙龙活动！");// }else{// System.out.println("您未受到邀请，请现场报名！");// }// String str = "李华玩得很开心！";// System.out.println(str.indexOf("开心"));// 5 计算给出字符串第一个出现的位置 String str2 = "李华成绩很好"; System.out.println(str2.length()); // 6 计算字符串的长度 String str3 = "李华喜欢看罗老师的视频"; str3.replace("李华","张三"); System.out.println(str3); //李华喜欢看罗老师的视频 并没有替换 字符串是不变的str3还是str3 String str4 = str3.replace("李华","张三");//几乎所有的字符串操作都会返回一个新字符串 新串要用新变量接 System.out.println(str4);//张三喜欢看罗老师的视频 String str5 = "哈哈_呵呵_嘻嘻_噢no"; String[] ss = str5.split("_");//切割 System.out.println(ss[0]);//哈哈 System.out.println(ss[1]);//哈哈 System.out.println(ss[2]);//嘻嘻 System.out.println(ss[3]);//噢no String str6 = "今天天气不错"; System.out.println(str6.substring(2,4));//天气 字符串截取 [ ) 左闭右开，右边取不到 String str7 =" 哈 哈 "; System.out.println(str7.trim());// 去掉左右两边的空格 int i = 10; System.out.println(String.valueOf(i)); // 基本数据类型转为字符串 System.out.println(i ""); // 野路子 }}七、String Builder和StringBufferString类的缺点：

String 是一个不可变的数据类型，每每拼接都会产生一个新的字符串，那么内存迟早会被这些拼接的字符串塞满。

StringBuilder和StringBuffer： 可变的字符串，不产生新对象，比较省内存 ，当进行大量的字符串拼接时建议使用StringBuffer和StringBuilder，但它们两个一些方法的实现几乎跟String一样。

【相似点】

两者用法一模一样，可以认为是一个类

【区别】

1. StringBuffer线程安全，StringBuilder非线程安全。
2. StringBuilder相比于StringBuffer有速度优势， 多数情况下建议使用StringBuilder类，但当被要求线程安全时必须使用StringBuilder类

字符串拼接方法：append()方法

StringBuffer和StringBuilder 转成String类 ：

StringBuilder sb = new StringBuilder("猫喜欢吃鱼");String s = sb.toString();

【参考代码】

package String;public class TestStringBuilder { public static void main(String[] args) { StringBuilder sb = new StringBuilder();// 一个空的字符串"" StringBuilder sb2 = new StringBuilder("猫喜欢吃鱼"); System.out.println(sb2);// 猫喜欢吃鱼 sb2.append("，狗也喜欢吃鱼"); System.out.println(sb2);// 追加 猫喜欢吃鱼，狗也喜欢吃鱼 sb2.insert(1,"哈哈哈"); System.out.println(sb2); //猫哈哈哈喜欢吃鱼，狗也喜欢吃鱼 // 上述的操作huan'c // 把StringBuilder转化成String String s = sb2.toString(); System.out.println(s); //猫哈哈哈喜欢吃鱼，狗也喜欢吃鱼 // 上述操作都可以将StringBuilder换成StringBuffer，结果一样 }}八、DecimalFormat

DecimalFormat：对小数进行格式化，保留几位小数。与格式化时间联想记。

. 表示小数点0和# 表示数位，保留几位就几个0或者#

【参考代码】

import java.text.DecimalFormat;import java.util.Scanner;public class Test { public static void main(String[] args) { double d= 10/3.0; System.out.println(d);//3.3333333333333335 // . 表示小数点 // 0和#表示数字 // 保留两位小数 格式 DecimalFormat df = new DecimalFormat(".00"); // 或者.## String s = df.format(d); // 把 d 转成上面设置的格式 System.out.println(s);//3.33 }}