1. 内部类
（1）内部类的分类
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
（2）内部类概念
-
**概念：**在一个类的内部再定义一个完整的类。
-
特点：
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类的私有成员，而不破坏封装
- 可为外部类提供必要的内部功能组件
（3）成员内部类
-
在类的内部定义，与实例变量、实例方法同级别的类
-
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
Outer out = new Outer(); Outer.Inner in = out.new Inner();
//一步到位
Inner inner = new Outer().new Inner();
-
当外部类、内部类存在同名属性时，会优先访问内部类属性。
此时要访问外部类属性，需要外部类名字.this.属性
Outer.this.name -
成员内部类不能定义静态成员。但可以定义静态常量
package com.dfl.commonclass.demo01; //外部类 public class Outer { //实例变量 private String name = "董方龙"; private int age = 22; //内部类 class Inner{ private String address = "武汉"; private String phone = "0853"; //方法 public void show(){ //打印外部类的属性 System.out.println(name); System.out.println(age); //打印内部类中的属性 System.out.println(address); System.out.println(phone); } } } //======================================================== package com.dfl.commonclass.demo01; public class TestOuter { public static void main(String[] args) { //创建一个外部类对象 Outer outer = new Outer(); //创建内部类对象 Outer.Inner inner = outer.new Inner(); inner.show(); } }
（4）静态内部类
- 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
package com.dfl.commonclass.demo02;
public class Outer {
private String name = "dfl";
private int age = 21;
//静态内部类,外部类相同级别
static class Inner{
private String address = "广州";
private String phone = "177";
//静态成员
private static int count = 1000;
public void show(){
//调用外部类的属性
//1.先创建外部类对象
Outer outer = new Outer();
//2.调用外部类对象的属性
System.out.println(outer.name);
System.out.println(outer.age);
//3.调用静态内部类的属性和方法
System.out.println(address);
System.out.println(phone);
//4.调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
}
//=====================================================
package com.dfl.commonclass.demo02;
public class TestOuter {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
//调用方法
inner.show();
}
}
只有内部类才可以使用static修饰
（5）局部内部类
-
定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法。
-
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的声明周期与自身相同，变量必须修饰为final
-
限制类的使用范围
package com.dfl.commonclass.demo03; public class Outer { private String name = "刘德华"; private int age = 35; public void show(){ //定义局部变量 String address ="深圳"; //局部内部类：不能加任何访问修饰符 class Inner{ private String phone = "17740500853"; private String email = "google.com"; public void show2(){ //访问外部类的属性 System.out.println(name); System.out.println(age); //访问内部类的属性 System.out.println(phone); System.out.println(email); //访问局部变量,jdk1.7要求变量必须是final，jdk1.8自动添加final System.out.println(address); } } //创建局部内部类对象 Inner inner = new Inner(); inner.show2(); } } //=============================================================== package com.dfl.commonclass.demo03; public class TestOuter { public static void main(String[] args) { Outer outer = new Outer(); outer.show(); } }
（6）匿名内部类
- 没有类名的局部内部类（一切特征都与局部内部类相同）
- 必须继承一个父类或者实现一个接口
- 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
- 优点：减少代码量
- 缺点：可读性较差
package com.dfl.commonclass.demo04;
public interface USB {
void service();
//服务
}
//=============================================
package com.dfl.commonclass.demo04;
public class TestUSB {
public static void main(String[] args) {
//创建接口类的变量
/*USB usb = new Mouse();
usb.service();*/
//局部内部类
/* class Fan implements USB{
@Override
public void service() {
System.out.println("连接电脑成功，风扇开始工作了。。。。");
}
}
//使用局部内部类创建对象
USB usb = new Fan();
usb.service();
*/
//使用匿名内部类优化(接口不能实例化，相当于创建了一个局部内部类)
USB usb = new USB() {
@Override
public void service() {
System.out.println("连接电脑成功，风扇开始工作了。。。。");
}
};
usb.service();
}
}
2. Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
- 任何类，如没有书写extends显示继承某个类，都默认继承Object类，否则为间接继承。
- Object类中定义的方法，是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象
3. Object类常用方法
（1）getClass() 方法
public final Class<?> getClass(){}
返回引用中存储的实际对象类型。
应用：通常用于判断两个引用中实际存储类型是否一致
（2）hashCode() 方法
-
public int hashCode(){}
-
返回该对象的哈希码值
-
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
-
一般情况下形同对象返回相同哈希码值
-
//hashCode方法 System.out.println(s1.hashCode()); System.out.println(s2.hashCode()); Student s3 = s1; System.out.println(s3.hashCode()); //s3和s1哈希值相同 /* 460141958 1163157884 460141958 */ //重写 @Override public int hashCode() { return Objects.hash(name, age); }
（3）toString() 方法
-
public String toString（）{}
-
返回该对象的字符串表示（表现形式）
-
可以根据程序需求覆盖该方法，如：展示对象各个属性值
-
//3.toString方法 System.out.println("--------------------3.toString------------------"); System.out.println(s1.toString()); System.out.println(s2.toString()); /*输出结果： com.dfl.commonclass.Object.demo01.Student@1b6d3586 com.dfl.commonclass.Object.demo01.Student@4554617c */ //可以重写 @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; }
（4）equals() 方法
public boolean equals(Object obj) {
return (this == obj);
}
比较两个对象地址是否相同。
//4.equals方法
System.out.println("--------------4.equals------------------");
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
可进行覆盖，比较两个对象的内容是否相同
equals()方法覆盖步骤
-
比较两个引用是否指向同一个对象
-
判断obj是否为null
-
判断两个引用指向的实际对象类型是否一致
-
强制类型转换
-
依次比较各个属性值是否相同。
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); }
（5）finalize() 方法
-
当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象,进入回收队列。
-
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
-
垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
-
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
-
手动回收机制：使用System.gc()；通知JVM执行垃圾回收。
public class TestStudent2 { public static void main(String[] args) { /*Student s1 = new Student("aaa",20); Student s2 = new Student("bbb",20); Student s3 = new Student("ccc",20); Student s4 = new Student("ddd",20); Student s5 = new Student("eee",20);*/ new Student("aaa",20); new Student("bbb",20); new Student("ccc",20); new Student("ddd",20); new Student("eee",20); //回收垃圾 System.gc(); System.out.println("回收垃圾"); } } /* 回收垃圾 eee对象被回收了 ddd对象被回收了 ccc对象被回收了 bbb对象被回收了 aaa对象被回收了 */
4. 包装类
Java Platform Standard Edition
（1）什么是包装类？
基本数据类型所对应的引用数据类型
Object可统一所有的数据，包装类的默认值是null
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
（2）类型转换与装箱、拆箱
-
装箱：自动将基本数据类型转换为包装器类型；
-
拆箱：自动将包装器类型转换为基本数据类型。
-
package com.dfl.commonclass.packaged.demo01; public class Demo01 { public static void main(String[] args) { //int num=10; //类型转换：装箱，基本类型转换为引用类型的过程 //基本类型 int num1 = 18; //使用Integer类创建对象 Integer integer1 = new Integer(num1); Integer integer2 = Integer.valueOf(num1); System.out.println("----------装箱-----------"); System.out.println(integer1); System.out.println(integer2); //类型转换：拆箱，引用类型装换位基本类型 Integer integer3 = new Integer(100); int num2 = integer3.intValue(); System.out.println("---------拆箱-------------"); System.out.println(num2); //JDK1.5之后，提供自动装箱和拆箱 int age = 30; //自动装箱 Integer integer4 = age; System.out.println("---------自动装箱-----------"); System.out.println(integer4); //自动拆箱 int age2 = integer4; System.out.println("---------自动拆箱-----------"); System.out.println(age2); } }
8种包装类提供不同类型间的转换方式：
- Number父类中提供的6个共性方法
- parseXXX（）静态方法
- valueOF（）静态方法
注意：需保持类型兼容，否则抛出NumberFormatException异常。
//接本类型和字符串之间转换
//1.基本类型转换为字符串
int n1 = 100;
//1.1使用+号
String s1 = n1 + "";
//1.2使用Integer中的toString()方法
String s2 = Integer.toString(n1,16); //f
System.out.println(s1);
System.out.println(s2);
//字符串转换为基本类型
String str = "150";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
System.out.println(n2);
//boolean字符串形式转换为基本类型.“true”--->true || "true"--->false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
（3）整数缓冲区
-
Java预先创建了256个常用的整数包装类型对象
-
在实际应用当中，对已创建的对象进行复用
-
public class Demo02 { public static void main(String[] args) { //面试题 Integer inter1 = new Integer(100); Integer inter2 = new Integer(100); System.out.println(inter1==inter2); //结果为：false Integer integer3=100; //自动装箱 Integer integer4=100; //调用的语句：Integer integer3=Integer.valueOf(100); System.out.println(integer3==integer4); //结果为：true Integer integer5=200; //自动装箱 Integer integer6=200; //调用的语句：Integer integer5=Integer.valueOf(200); //valueOf System.out.println(integer5==integer6); //结果为：false //在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间， //便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。 } }
5. String类
（1）String概述
-
字符串是常量，创建之后不可改变
-
字符串字面值存储在字符串池中，可以共享
-
String s = “Hello”;产生一个对象，字符串池中存储
-
String s = new String(“Hello”);//产生两个对象，堆、池各存储一个
- 堆和方法区（字符串池）各有一个“Hello”对象，但是栈里的s指向堆里的·“Hello”
String str = new String("java"); String str2 = new String("java"); System.out.println(str==str2); //false 地址 System.out.println(str.euqals(str2)); //true 数据
（2）常用方法
-
public int length（）：返回字符串的长度
-
public char charAt（int index）：根据下标获取字符。
-
public boolean contains（String str）：判断当前字符串中是否包含str
-
public char[] toCharArray（）：将字符串转换成数组
-
public int indexOF（String str）：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
-
public int lastIndexOF（String str）：查找字符串在当前字符串最后一次出现的下标索引。
-
public String trim（）：去掉字符串前后的空格
-
public String toUpperCase（）将小写转成大写
-
public boolean endWith（String str）：判断字符串是否以str结尾
-
public String replace（char oldChar,char newChar）;将旧字符串替换成新字符串
-
public String[] split(String str):根据str做拆分
package com.dfl.commonclass.String; import java.util.Arrays; import java.util.Locale; public class Demo03 { public static void main(String[] args) { String name = "hello"; name = "张三"; System.out.println("--------字符串方法的使用1--------"); //字符串方法的使用 //1.length();返回字符串的长度 //2.charAt(int index);返回某个位置的字符 //3.contains(String str);判断是否包含某个子字符串 String content = "java是世界上最好的java编程语言,java真好"; // System.out.println(content.length()); System.out.println(content.charAt(content.length()-1)); System.out.println(content.contains("java")); System.out.println(content.contains("php")); System.out.println("--------字符串方法的使用2--------"); //字符串方法的使用 //4.toCharArray（）：将字符串转换成数组 //5.indexOF();返回子字符串首次出现的位置 //6.lastIndexOF()返回字符串最后一次出现的位置 System.out.println(content.toCharArray()); System.out.println(Arrays.toString(content.toCharArray())); System.out.println(content.indexOf("java")); System.out.println(content.indexOf("java",4)); System.out.println(content.lastIndexOf("java")); System.out.println("--------字符串方法的使用3--------"); //7.trim();去掉字符串前后的空格 //8.toUpperCase();把小写转成大写 toLowerCase()把大写转成小写 //9.endWith(str);判断是否以str结尾 StartWith(str);判断是否以str开头 String comtent2 = " hello world "; System.out.println(comtent2.trim()); System.out.println(comtent2.toUpperCase()); System.out.println(comtent2.toLowerCase()); String filename = "hello.java"; System.out.println(filename.endsWith(".java")); System.out.println(filename.startsWith("hello.")); System.out.println("--------字符串方法的使用3--------"); //10.replace(char old,char new);用芯替旧 //11.split();拆分 System.out.println(content.replace("java","php")); String say = "java is the,best programing language ,123"; String[] arr = say.split("[ ,]+"); System.out.println(arr.length); for (String string : arr) { System.out.println(string); } //补充两个方法equals、compareTo();比较大小 String s1 = "hello"; String s2 = "HELLO"; System.out.println(s1.equals(s2)); System.out.println(s1.equalsIgnoreCase(s2)); String s3 = "abc"; //97 String s4 = "xyz"; //120 System.out.println(s3.compareTo(s4)); //-23 String s5 = "abcxyz"; System.out.println(s3.compareTo(s5)); //此时比较长度 -3 } }
（3）案例
需求：
- 已知String str = “this is a text”
- 将str中的单次单独提取出来
- 将str2中的text替换为practice
- 在text前插入一个easy
- 将每个单次的首字母改为大写
package com.dfl.commonclass.String;
/**
*@ClassName: Demo04
*@Description
*@Author 董方龙
*@Date
*@Time 19:36
*
* **需求：**
*
* - 已知String str = "this is a text"
* 1. 将str中的单次单独提取出来
* 2. 将str2中的text替换为practice
* 3. 在text前插入一个easy
* 4. 将每个单次的首字母改为大写
*/
public class Demo04 {
public static void main(String[] args) {
String str ="this is a text";
//1.将str中的单次单独获取出来
String[] arr = str.split(" ");
System.out.println("------将str中的单次单独获取出来------");
for (String s :
arr) {
System.out.println(s);
}
//2.将str的text替换为practice
String str2 = str.replace("text","practice");
System.out.println(str2);
//3.在text前面插入一个easy
System.out.println("------3.在text前面插入一个easy------");
String str3 = str.replace("text","easy text");
System.out.println(str3);
//4.将每个单次首字母改为大写
for (int i = 0; i < arr.length; i++) {
char first = arr[i].charAt(0);
//把第一个字符装换为大写
char upperfirst = Character.toUpperCase(first);
String news = upperfirst +arr[i].substring(1);
System.out.println(news);
}
}
}
（4）可变字符串
-
StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全。
-
StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全（单线程用）
package com.dfl.commonclass.String; /** *@ClassName: Demo05 *@Description StringBuffer 和 StringBuilder的使用 * 和String区别 （1）效率比String高 （2）比String节省内存 *@Author 董方龙 *@Date *@Time 20:02 */ public class Demo05 { public static void main(String[] args) { StringBuffer stringBuffer = new StringBuffer(); System.out.println(stringBuffer.toString()); //1.append();追加 stringBuffer.append("java世界第一"); System.out.println(stringBuffer.toString()); stringBuffer.append("java真香"); System.out.println(stringBuffer.toString()); stringBuffer.append("java不错"); System.out.println(stringBuffer.toString()); //2.insert();添加 stringBuffer.insert(0,"我在最前面"); System.out.println(stringBuffer.toString()); //3.replace(); stringBuffer.replace(0,5,"hello"); System.out.println(stringBuffer.toString()); //4.delete();删除 stringBuffer.delete(0,5); System.out.println(stringBuffer.toString()); //清空· stringBuffer.delete(0,stringBuffer.length()); System.out.println(stringBuffer.toString()); } }package com.dfl.commonclass.String; /** *@ClassName: Demo06 *@Description 验证StringBuilder效率高于String *@Author 董方龙 *@Date *@Time 20:44 */ public class Demo06 { public static void main(String[] args) { //开始时间 long start = System.currentTimeMillis(); /* String string = ""; for (int i = 0; i < 99999; i++) { string +=i; } System.out.println(string);*/ StringBuilder sb = new StringBuilder(""); for (int i = 0; i < 99999; i++) { sb.append(i); } System.out.println(sb.toString()); long end = System.currentTimeMillis(); System.out.println("用时："+(end-start)); } }
6. Bigdecimal类
（1）思考
package com.dfl.commonclass.bigdecimal;
public class Demo07 {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);
double result = (1.4-0.5)/0.9;
System.out.println(result);
}
}
输出结果为：
0.09999999999999998
0.9999999999999999
Bigdecimal类精度更高
（2）概述
位置：java.math包中
作用：精确计算浮点数
创建方式：BigDecimal bd = new BigDecimal(“1.0”);
package com.dfl.commonclass.bigdecimal;
import java.math.BigDecimal;
public class Demo07 {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);
double result = (1.4-0.5)/0.9;
System.out.println(result);
//BigDecimal
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);
//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);
//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);
//除法
BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
System.out.println(r4);
BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//保留两位小数，四舍五入
System.out.println(r5);
}
}
除法：divide（BigDecimal bd , int scal , RoundingMode mode）
参数scal：指定精确到小数点后几位
参数mode：
- 指定小数点后的取舍模式，通常采用四舍五入的模式
- 取值为BigDecimal.ROUND_HALF_UP
7. Date类
- Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
- 时间单位
- 1秒 = 1000毫秒
- 1毫秒 = 1000微秒
- 1微秒 = 1000纳秒
package com.dfl.commonclass.date;
import java.util.Date;
public class Demo01 {
public static void main(String[] args) {
//1.创建Date对象
//今天
Date date1 = new Date();
System.out.println(date1.toString());
System.out.println(date1.toLocaleString());
//昨天
Date date2 = new Date(date1.getTime()-(60*60*24*1000));
System.out.println(date2.toLocaleString());
//2.方法 after 和 before
boolean b1 = date1.after(date2);
System.out.println(b1);
boolean b2 = date1.before(date2);
System.out.println(b2);
//比较compareTo();
int d = date1.compareTo(date2);
System.out.println(d);
int e = date1.compareTo(date1);
System.out.println(e);
int f = date2.compareTo(date1);
System.out.println(f);
//比较是否相等equals();
boolean g =date1.equals(date2);
System.out.println(g);
}
}
8.SimpleDateFormat
-
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
-
进行格式化（日期 –> 文本）、解析（文本 –> 日期）
-
常用的时间模式字母
字母 日期或时间 示例 y 年 2019 M 年中月份 08 d 月中天数 10 H 1天中小时数（0-23） 22 m 分钟 16 s 秒 59 S 毫秒 367 package com.dfl.commonclass.simpleDateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class Demo07 { public static void main(String[] args) throws ParseException { //1.创建SimpleDateFormat对象 y年 M月 //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss"); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); //2.创建Date Date date = new Date(); //格式化Date()把日期转换成字符串 String str = sdf.format(date); System.out.println(str); //解析(把字符串转换成日期) Date date2 = sdf.parse("2000/06/04"); System.out.println(date2); } }
9. System类
- System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。
| 方法名 | 说明 |
|---|---|
| static void arraycopy(…) | 复制数组 |
| static long currentTimeMills(); | 获取当前系统时间，返回的是毫秒值 |
| static void gc(); | 建议JVM赶快启动垃圾回收机制 |
| static void exit (int status) | 退出JVM，如果参数是0表示正常退出jvm，非0表示异常退出jvm |
package com.dfl.commonclass.system;
public class Demo08 {
public static void main(String[] args) {
//arraycopy:数组的复制
//src:源数组
//srcPos:从哪个位置开始复制 0
//dest:目标数组
//destPos:目标数组的位置
//length:复制的长度
int[] arr = {20,18,15,8,35,26,45,90};
int[] dst = new int[8];
System.arraycopy(arr,4,dst,0,2);
for (int i = 0; i < dst.length; i++) {
System.out.print(dst[i]+" ");
}
//Arrays.copyOf(original,newLength)
System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for (int i = 0; i < 999999999; i++) {
for (int j = 0; j < 999999; j++) {
int result = i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时："+(end-start));
Student s1 = new Student("aaa",18);
Student s2 = new Student("bbb",18);
Student s3 = new Student("ccc",18);
System.gc(); //告诉垃圾回收期回收
new Student("a",7);
new Student("b",8);
new Student("c",9);
System.gc(); //告诉垃圾回收期回收
/*输出
回收了a 7
回收了b 8
回收了c 9*/
System.exit(0);
System.out.println("程序结束了"); //这条语句没有执行
}
}
//=====================================================================
package com.dfl.commonclass.system;
public class Student {
private String name ;
private int age;
public Student(String name, int age) {
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;
}
@Override
public String toString() {
return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
}
@Override
protected void finalize() throws Throwable {
System.out.println("回收了"+name+" "+age);
}
}
10.总结
-
内部类：
- 在一个类的内部再定义一个类
- 成员内部类、静态内部类、局部内部类、匿名内部类
-
Object类：
- 所有类的直接或间接父类，可存储任何对象
-
包装类：
- 基本数据类型所对应的引用数据类型，可以使用Object统一所有数据
-
String类：
- 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
-
BigDecimal：
- 可精确计算浮点数。
-
Date
- 特定时间
-
Calendar
- 日历
-
SimpleDateFormat
- 格式化时间
-
System
- 系统类
码字不易，请大家点赞关注一下，一起进步嗷！
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
