内部类
成员内部类、静态内部类、局部内部类、匿名内部类
概念:在一个类的内部再定义一个完整的类
特点:
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类私有成员,而不破坏封装
- 可为外部类提供必要的内部功能组件
class Body{
// 头部
class Header{
// 也会生成class文件
}
}
Outer$Inner.class Outer.class
成员内部类
- 在类的内部定义,与实例变量、实例方法同级别的类
- 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象
- 当外部类、内部类存在重名属性时,会优先访问内部类属性
- 成员内部类里不能定义静态成员、可以包含静态常量(final)
public class Outer {
private String name="伊布";
private int age=40;
class Inner{
private String address="瑞典";
private String skill="头球";
private String name="卡瓦尼"; //属性与外部类相同,优先调用内部类的
public void show(){ //成员内部类
//打印外部类属性,内外属性名字相同,Outer.this.name
System.out.println(Outer.this.name);
System.out.println(age);
System.out.println(address);
System.out.println(skill);
}
}
}
public class TestOuter {
public static void main(String[] args) {
//创建一个外部类对象new
// Outer outer=new Outer();
//创建一个内部类对象
// Outer.Inner inner=outer.new Inner();
Outer.Inner inner=new Outer().new Inner();
inner.show();
}
}
静态内部类
不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员
public class Outer {
private String name="伊布";
private int age=40;
//静态内部类,级别和外部类相同,给外部类提供功能
static class Inner{
private String address="瑞典";
private String skill="头球";
private static int cout=200;
public void show(){
//调用外部类的属性
//1.先创建外部类对象
Outer outer = new Outer();
// 2. 调用外部类对象的属性
System.out.println(outer.age);
System.out.println(outer.name);
//调用静态内部类的属性和方法
System.out.println(address);
System.out.println(skill);
System.out.println(Inner.cout);
}
}
}
public class TestOuter {
public static void main(String[] args) {
Outer.Inner inner=new Outer.Inner();
inner.show();
}
}
局部内部类
- 定义在外部类方法中,作用范围和创建对象范围仅限于当前方法
- 局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final
- 限制类的使用范围
需要在类外创建局部内部变量(new一个),完事儿之后在测试类直接调用方法就能用了
public class Outer {
private String name="伊布";
private int age=40;
public void show(){
//定义局部变量
final String address="瑞典";
//局部内部类:注意不能加任何访问修饰符
class Inner{
private String phone="15002265";
private String email="1546@qq.coom";
public void show2(){
//访问外部类的属性
System.out.println(Outer.this.name);
System.out.println(age);
System.out.println(this.email);
System.out.println(this.phone);
//访问局部变量
System.out.println(address);
}
}
//创建局部内部变量
Inner inner = new Inner();
inner.show2();
}
}
public class TestOuter {
public static void main(String[] args) {
Outer outer = new Outer();
outer.show();
}
}
匿名内部类
- 没有类名的局部内部类(一切特征都与局部内部类相同)
- 必须继承一个父类或者实现一个接口
- 定义类、实现类、创建对象的语法合并,只能创建一个该类的对象
- 优点:减少代码量
- 缺点可读性较差
public interface Usb {
void service();
}
public class Mouse implements Usb{
@Override
public void service() {
System.out.println("连接成功");
}
}
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("连接成功2222");
}
}
//使用局部内部类创建对象
// Usb usb = new Fan();
// usb.service();
// 使用匿名内部类优化(相当于创建了一个局部内部类)
Usb usb = new Usb(){ // Usb为一个接口
@Override
public void service(){
System.out.println("连接电脑成功,fan开始工作");
}
};
usb.service();
}
}
Object类
- 超类、基类,所有类的直接或间接父类,位于继承树的最顶层
- 任何类,如没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承
- Object类中所定义的方法,是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数,可接受任何对象
- 作为返回值,可返回任何对象
getClass()方法
- 返回引用中存储的实际对象类型
- 应用:通常用于判断两个引用中实际存储对象类型是否一致
hashCode()方法
- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
- 一般情况下相同对象返回相同哈希码
toString方法
- 返回该对象的字符串表示(表现形式)
- 可以根据程序需求覆盖该方法,如:展示对象各个属性值
equals方法
- 默认实现为(this == obj), 比较两个对象地址是否相同
- 可进行覆盖,比较两个对象的内容是否相同
public class Student {
private String name;
private int age;
public Student(){}
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
public boolean equals(Object obj) {
if(this == obj){
return true;
}
// 2.
if(obj == null){
return false;
}
// 3.
// if(this.getClass() == obj.getClass()){
//
// }
// instanceof 判断对象是否是某种类型
if(obj instanceof Student){
// 4.强制类型转换
Student s = (Student)obj;
// 5. 比较属性
if(this.name.equals(s.getName()) && this.age == s.getAge()){
return true;
}
}
return false;
}
}
public class TestStudent {
public static void main(String[] args) {
//1.getClass方法
//通常用于判断两个引用中实际存储对象类型是否一致
//判断s1 和 s2是不是同一个类型
Student s1 = new Student("AAA",45);
Student s2 = new Student("ddd",454);
//判断s1 和 s2是不是同一个类型
Class class1=s1.getClass();
Class class2=s2.getClass();
if(class1==class2){
System.out.println("s1和s2属于同一个类型");
}else{
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("----------2.hashCode方法---------");
//2.hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3=s1;
System.out.println(s3.hashCode());
System.out.println("----------3.toString方法---------");
//3.toString方法
System.out.println(s1.toString());
System.out.println(s2.toString());
System.out.println("----------4.equals方法-----------");
//4.equals方法:判断两个对象是否相等 (比较两个对象地址是否相同)
System.out.println(s1.equals(s2));//false
Student s4 = new Student("小明",17);
Student s5 = new Student("小明",17);
System.out.println(s4.equals(s5));//false,堆中地址不同,现在是true了,因为已经重写了方法
//要想为true,直接重写equals方法
}
}
finalize方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象
- 垃圾回收:由gc销毁垃圾对象,释放数据存储空间
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
- 手动回收机制:使用
System.gc();
通知JVM执行垃圾回收
基本都是系统自动回收,很少手动回收,了解就行