1.0 常用类
1.内部类
成员内部类、静态内部类、局部内部类、匿名内部类
概念：在一个类的内部再定义一个完整的类
特点：
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类私有成员，而不破坏封装
- 可为外部类提供必要的内部功能组件
Outer$Inner.class` `Outer.class
//身体
public class Body {
private String name;
//头部
class Header{
public void show(){
System.out.println(name);//内部类可以直接访问外部类的是有元素
}
}
}
1.1成员内部类
1.2静态内部类
- 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
//外部类 public class Outter { private String name = "yujian"; private int age = 19; public void shout(){ System.out.println("不要叫"); } //静态内部类，和外部类相同 static class Inner { private String address = "北京"; private String phone = "110"; //静态属性 private static int count = 1000; //方法 public void show(){ //打印外部类的属性(需要创建对象来访问外部类属性与方法) Outter outter = new Outter(); System.out.println(outter.age); outter.shout(); //调用内部类属性和方法 System.out.println(address); System.out.println(phone); //调用静态内部类的静态属性(但都是静态时，可以直接使用里面的东西) System.out.println(count); } } } //测试类 public class TestOutter { public static void main(String[] args) { Outter.Inner inner = new Outter.Inner(); inner.show(); } }
1.3局部内部类
- 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
- 限制类的使用范围
//外部类 public class Outter { private String name = "yujian"; private int age = 19; private int id = 1; public void show(){ //定义局部变量 String address = "广州"; //局部内部类(在方法里面):注意：不能加任何访问修饰符 class Inner{ //局部内部类的属性 private String phone = "155088"; private String email = "11111"; public void show2(){ //访问外部类的属性(3种方法都可以) Outter outter = new Outter(); System.out.println(outter.id); System.out.println(Outter.this.name); System.out.println(age); //访问内部类的属性(2种方法都可以) System.out.println(phone); System.out.println(this.email); //访问局部变量(jdk1.7要求必须是常量final，jdk1.8自动添加final) System.out.println(address); } } //创建局部内部类对象 Inner inner = new Inner(); inner.show2(); } } /* 局部内部类不能包含静态的成员 如：在class Inner中，添加private static int count = 2000;会报错 但(添加静态常量是没错)private final static int count = 2000;不会报错 */ //测试类 public class TestOutter { public static void main(String[] args) { Outter outter = new Outter(); outter.show(); } } 运行outter.show(),然后运行inner.show2()
1.4匿名内部类
- 没有类名的局部内部类（一切特征都与局部内部类相同）
- 必须继承一个父类或者实现一个接口
- 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
- 优点：减少代码量
- 缺点可读性较差
// 使用匿名内部类优化（相当于创建了一个局部内部类） Usb usb = new Usb(){ // Usb为一个接口 @Override public void service(){ sout("连接电脑成功，fan开始工作") } }; usb.service();
2.Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
- 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
- Object类中所定义的方法，是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象
2.1getClass()方法
-
public final Class<?> getClass(){} - 返回引用中存储的实际对象类型
- 应用：通常用于判断两个引用中实际存储对象类型是否一致
// 判断s1 和 s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// getClass返回 class类型
**完整代码**
```java
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("yujian",19);
Student s2 = new Student("gao",20);
//判断s1余s2是否为同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 ==class2){
System.out.println("类型相同");
}
else{
System.out.println("不同类型");
}
}
}
2.2hashCode()方法
-
public int hashCode(){} - 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
- 一般情况下相同对象返回相同哈希码
s1.hashCode(); s2.hashCode(); // 自然不同 Student s3 = s1; // 此时s3的hashCode与s1相同 完整代码
public class TestStudent { public static void main(String[] args) { Student s1 = new Student("yujian",19); Student s2 = new Student("gao",20); // hashCode()方法 System.out.println(s1.hashCode());//1013423070 System.out.println(s2.hashCode());//380936215 Student s3 = s1;//s3地址与s1相同 System.out.println(s3.hashCode());//1013423070 } }
2.3 toString()方法
-
public String toSring(){} - 返回该对象的字符串表示（表现形式）
- 可以根据程序需求覆盖该方法，如：展示对象各个属性值
sout(s1.toString()); // 直接打印包+类名+哈希值 // 在Eclipse重写 alt + enter + s // 在idea中从写 Alt +Insert @override public String toString(){ return "Student [name = " + name + ", age = " + age + "]"; } 完整代码
public class Student { private String name; private int age; public Student(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return name+" "+age; } } //测试类 public class TestStudent { public static void main(String[] args) { Student s1 = new Student("yujian",19); Student s2 = new Student("gao",20); //toString()方法 System.out.println(s1.toString()); System.out.println(s2.toString()); } }
2.4equals()方法
-
public boolean equals(Object obj){} - 默认实现为(this == obj), 比较两个对象地址是否相同
- 可进行覆盖，比较两个对象的内容是否相同
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
//1.判断2个对象是否为同一个引用
if (this ==obj){
return true;
}
//2.判断object是否为null
if (obj==null){
return false;
}
//3.判断是否是同一个类型
// if (this.getClass() ==obj.getClass()){
// return true;
// }
//instanceof 可以判断对象是否是某种类型
if (obj instanceof Student){
//类型转换
Student s = (Student) obj;
//比较
if (this.name.equals(s.getName())&&this.age==s.age){
return true;
}
}
return false;
}
}
//测试类
public class TestStudent {
public static void main(String[] args) {
//1.getClass()方法
Student s1 = new Student("yujian",19);
Student s2 = new Student("gao",20);
//4.equals()方法：判断2个对象是否相等
System.out.println(s1.equals(s2));
Student s4 = new Student("小明",17);
Student s5 = new Student("小明",17);
System.out.println(s4.equals(s5));
}
}
2.5 finalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
- 垃圾对象：没有有效引用指向此对象时，为垃圾对象
- 垃圾回收：由gc销毁垃圾对象，释放数据存储空间
- 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
- 手动回收机制：使用
System.gc();通知JVM执行垃圾回收
@Override
protected void finalize() throws Throwable{
sout(this.name + "对象被回收了");
}
psvm(String[] args){
Student s1 = new Student("aaa", 29); // 不是垃圾
new Student("bbb", 30); // 是辣鸡 会被回收
//回收垃圾
System.gc();
sout("回收垃圾");
// 打印出 “回收垃圾
// aaa对象被回收了”
}
3.包装类
- 基本数据类型所对应的引用数据类型
- Object 可统一所有数据，包装类的默认值是null
基本数据类型 | 包装类型 |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
3.1类型转换和封箱、拆箱
将基本类型转换为引用类型为封箱，将引用类型转换为基本类型为拆箱
- 8种包装类提供不用类型间的转换方式
- Number父类中提供的6个共性方法
\2. parseXXX( )静态方法
\3. valueOf( )静态方法
注意：需保证类型兼容，否则抛出NumberFormatException异常
public class Demo01 {
public static void main(String[] args) {
//类型转换：装箱:基本类型转换为引用类型
//基本类型
int num1 = 18;
//使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
System.out.println("装箱");
System.out.println(integer1+" "+integer2);
System.out.println();
//基本类型：拆箱：引用类型转换为基本类型
System.out.println("拆箱");
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
System.out.println(num2);
System.out.println();
// JDK1.5之后，提供自动装箱和拆箱
int age = 20;
//自动装箱
System.out.println("自动装箱");
Integer integer4 = age;
System.out.println(integer4);
//自动拆箱
System.out.println("自动拆箱");
int age2 = integer4;
System.out.println(age2);
System.out.println();
//基本类型与字符串类型之间的转换
System.out.println("=====基本类型与字符串类型之间的转换=====");
//1.基本类型转换为字符串
int n1 = 15;
//1.1使用+号
String s1 = n1+"";
//1.2使用Interger中的toString()方法
String s2 = Integer.toString(n1);
String s3 = Integer.toString(n1,2);//radix表示想要转换为几进制的
System.out.println(s1+" "+s2+" "+s3);
System.out.println();
//2.字符串类型转化为基本类型
String str="155";
//使用Interger.parseXXX(); XXX为你要转换为哪种基本类型
int a1 = Integer.parseInt(str);
System.out.println(a1);
//boolean字符串形式转换为基本类型："true"--->true 非"true"--->false
String str2 = "true";
String str3 = "truaa";
boolean a2 = Boolean.parseBoolean(str2);
boolean a3 = Boolean.parseBoolean(str3);
System.out.println(a2+" "+a3);
}
}
3.2整数缓冲区
- Java预先创建了256个常用的证书包装类型对象
- 在实际应用当中，对已创建的对象进行复用
public class Demo02 {
public static void main(String[] args) {
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1 == integer2);//比较的是地址 false
Integer integer3 = Integer.valueOf(100);//自动装箱 //自动装箱调用的是Integer.ValueOf
Integer integer4 = 100;
System.out.println(integer3 == integer4);//true
Integer integer5 = 200;//自动装箱
Integer integer6 = 200;
//Integer的范围在-128~127，当范围超出，会创建新的对象，所以integer5和interger6是2个对象，所以是false
System.out.println(integer5 == integer6);
}
}
作者：GD1_1DG
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
