常用类
1. 内部类
概念：在一个类的内部再定义一个完整的类
特点：
1.编译之后可以生成独立的字节码文件。
2.内部类可以直接访问外部类的私有成员，而不破坏封装。
3.内部类可为外部类提供必要的内部功能组件。
实例：
public class Body {//外部类
private String name;
class Header{//内部类
public void show(){
System.out.println(name);
}
}
}
成员内部类
在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例对象，创建内部类对象时，必须依赖外部类对象。
当外部类、内部类存在重名属性时，会优先访问内部类属性。
成员内部类不能定义静态成员。
实例：
public class Outer {//外部类
private String name = "张三";
private int age = 20;
class Inner{//内部类
private String address = "北京";
private String phone = "110";
public void show(){
//打印外部类中的属性
System.out.println(name);
System.out.println(age);
//打印外部类中的属性
System.out.println(address);
System.out.println(phone);
}
}
}
启动类：
public class TestOuter {
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();
inner.show();
}
}
静态内部类
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
实例：
public class Outer {//外部类
private String name = "张三";
private int age = 20;
static class Inner{//静态内部类
private String address = "北京";
private String phone = "110";
private static int count = 100;//静态成员
public void show(){
//1.创建外部类对象
Outer outer = new Outer();
//2.调用外部类对象的属性
System.out.println(outer.name);
System.out.println(outer.age);
//调用静态内部类的属性
System.out.println(address);
System.out.println(phone);
//调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
}
实例：启动类
public class TestOuter {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
inner.show();
}
}
局部内部类
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的声明周期与自身相同，变量必须修饰为final。
限制类的使用范围。
实例：
public class Outer {//外部类
private String name = "张三";
private int age = 20;
public void show(){
//定义局部变量
String address = "郑州";
//局部内部类:不能加任何方法修饰符
class Inner{
//局部内部类属性
private String phone = "15566668888";
private String email = "yazhou@qq.com";
public void show2() {
//访问外部类属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//访问内部类
System.out.println(this.email);
System.out.println(this.phone);
}
}
//创建局部内部类你对象
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("连接电脑成功，风扇开始工作！！！");
// }
// }
// //使用局部内部类创建对象
// 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类型可以存储任何对象。
作为参数，可以接受任何对象。
作为返回值，可返回任何对象。
getClass()方法
public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用：通常用于判断两个引用中实际存储对象类型是否一致。
实例：
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;
}
}
实例：启动
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",22);
//判断s1与s2是不是同一个类型
Class<? extends Student> aClass = s1.getClass();
Class<? extends Student> bClass = s2.getClass();
if (aClass == bClass){
System.out.println("同一种类型");
}else{
System.out.println("不是同一种类型");
}
}
}
hashCode()方法
public int hashCode(){}
返回该对象的哈希码值。
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
一般情况下相同对象返回相同哈希值。
实例：
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",22);
//判断s1与s2是不是同一个类型
Class<? extends Student> aClass = s1.getClass();
Class<? extends Student> bClass = s2.getClass();
if (aClass == bClass){
System.out.println("同一种类型");
}else{
System.out.println("不是同一种类型");
}
//hashCode()方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
}
}
toString()方法
public String toString(){}
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值
实例：
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;
}
public String toString(){
return name+":"+age;
}
}
实例：
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",22);
//判断s1与s2是不是同一个类型
Class<? extends Student> aClass = s1.getClass();
Class<? extends Student> bClass = s2.getClass();
if (aClass == bClass){
System.out.println("同一种类型");
}else{
System.out.println("不是同一种类型");
}
//hashCode()方法
System.out.println(s1.toString());
System.out.println(s2.toString());
}
}
equals()方法
public boolean equals(Object obj){}
默认实现为(this == obj),比较两个对象地址是否相同。
可进行覆盖，比较两个对象的内容是否相同。
equals()方法覆盖步骤：
1.比较两个引用是否指向同一对象。
2.判断obj是否为null。
3.判断两个引用指向的实际对象类型是否一致。
4.强制类型转换。
5.依次比较各个属性值是否相同。
实例：
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;
}
public String toString(){
return name+":"+age;
}
@Override
public boolean equals(Object obj) {
if (this == obj){
return true;
}
if (obj == null){
return false;
}
if(obj instanceof Student){
Student s = (Student) obj;
if (this.name.equals(s.getName())&&this.age==s.getAge()){
return true；
}
}
return false;
}
}
实例：
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",22);
//判断s1与s2是不是同一个类型
Class<? extends Student> aClass = s1.getClass();
Class<? extends Student> bClass = s2.getClass();
if (aClass == bClass){
System.out.println("同一种类型");
}else{
System.out.println("不是同一种类型");
}
//hashCode()方法
System.out.println(s1.equals(s2));
}
}
finalize()方法
当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc();通知JVM执行垃圾回收。
实例：
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;
}
public String toString(){
return name+":"+age;
}
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"对象被回收了");
}
}
实例：
public class TestStudent {
public static void main(String[] args) {
new Student("aaa",20);
new Student("bbb",21);
new Student("ccc",22);
new Student("ddd",23);
new Student("eee",24);
new Student("fff",25);
//回收垃圾
System.gc();
System.out.println("回收垃圾");
}
}
3. 包装类
基本数据类型所对应的引用数据类型。
浙公网安备 33010602011771号