java基础之常用类1

java基础

---

以下内容为本人的学习笔记，如需要转载，请声明原文链接  

---

java常用类：

1.内部类

2.Object类

3.Object类常用方法

4.包装类

5.String类

6.BigDecimal类

1、内部类

• 分类：

  内部类：成员内部类，静态内部类， 局部内部类，匿名内部类

• 概念：在一个类的内部再定义一个完整的类（类中类）

• 特点：

1. 编译之后可生成独立的字节码文件；

2. 内部类可直接访问外部类的私有成员，而不破坏封装

3. 可为外部类提供必要的内部功能组件

public class Body{
    private String name;
    //内部类
    class Header{
        public void show(){
            //访问外部类私有成员
        System.out.println(name)
        }
    }
}

1.1成员内部类

• 在类的内部定义，与实例变量、示例方法同级别的类；

• 外部类的一个实例部分，创建内部类对象时，必须先创建外部类对象：

　　　　Outer out = new Outer();

　　　　out.Inner in = out.new Inner();

• 当外部类、内部类存在重名属性时，会优先访问内部类属性；

• 成员内部类不能定义静态成员，但是能定义静态常量。

示例：

public class Outer{
    private String name="张三";
    private int age = 20;

    //内部类
    class Inner{
        private String address = "北京";
        private String phone="110";
        private String name = "李四";

        //方法
        public void show(){
            //打印外部类的属性，内部类属性和外部类的属性名字相同(重名时)：Outer.this
            System.out.println(Outer.this.name);
            System.out.println(age);

            //打印内部类中的属性
            System.out.println(this.address);
            System.out.println(phone);
        }

    }
}
​
public class TestOuter{
    public static void main(String [] agrs){
        //1创建外部类对象
  //      Outer outer = new Outer();
        //2创建内部类对象，要加外部类对象前缀
  //      outer.Inner inner = outer.new Inner()

          //1,2合并为一句
        Inner inner = new Outer().new Inner();
        inner.show();
    }
}

1.2静态内部类

(静态内部类，在内部类基础上加static,级别相当于外部类，给外部类使用)

• 不依赖（先创建）外部类对象，可直接创建或通过类名访问，可声明静态成员

• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）

　　　　Outer.Inner inner = new Outer.Inner();

　　　　Outer.Inner.show();

示例：

public class Outer {
​
    private String name ="小米";
    private int age = 19;
​
    //静态内部类
    static class Inner{
        private String name = "计缘";
        private int age =11;
        static private String address = "广东";
        public void show(){
            //1.调用外部类的属性，先创建外部类对象，因为静态内部类与外部类属于同一级别
            Outer outer = new Outer();
            //2.调用外部类的属性
            System.out.println(outer.name);
            //3.调用静态内部类的属性
            System.out.println(name);
            //4.调用静态内部类的静态属性，类名.属性名
            System.out.println(Inner.address);
        }
​
​
    }
}
//测试
public class TestOuter {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}
​

1.3局部内部类

1. 定义在外部类方法中，作用范围和创建对象仅限于当前方法；

   • 局部内部类前缀不能加任何访问修饰符（如，public，protect...),作用范围在方法里

   • 局部内部类和局部变量属于同一级别

   • 静态方法不能访问非静态的成员，因为静态属性是类的属性，不是单个成员的属性

   • 局部内部类不能定义静态变量，但可以定义静态常量

2. 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final；

3. 限制类的使用范围。

　　  局部内部类访问局部变量：

• • 　　访问局部变量,JDK1.7要求变量是常量final，JDK1.8会自动为局部变量添加final；

  • 　　因为局部变量在方法完成后会消失，但是局部内部类不会消失，可是局部内部类会使用到一个将要消失的局部变量？所以要让局部变量为常量。

public class Outer {
​
    private String name = "计缘";
    private int age = 42;
​
    public void show(){
        String address = "广东";
        class Inner{
            private String name = "尹兆先";
            private int age = 43;
​
            public void show2(){
                //访问外部类的属性，Outer.this可省略
                System.out.println(Outer.this.name);
                System.out.println(age);
​
                //访问内部类的属性
                System.out.println(name);
                //访问局部变量,JDK1.7要求变量是常量final，JDK1.8会自动为局部变量添加final
                System.out.println(address);
            }
        }
        //不能在main方法里创建局部内部类对象，
        // 在main方法里调用外部类的show方法是不能调用局部内部类的，因为
        // 上面只做了声明，没有调用。
        // 要调用局部内部类的方法要在上一级方法（跟局部内部类同一级上）创建局部内部类对象并调用方法
        Inner inner = new Inner();
        inner.show2();
    }
}
​
​
//测试
public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}
​

1.4匿名内部类

1. 没有类名的局部内部类（一切特征都与局部内部类相同）；

2. 必须继承一个父类或者实现一个接口；

3. 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象；

• 优点：减少代码量；

• 缺点：可读性较差。

示例：

public interface Usb {
    public void service();
}
​
​
public class Mouse implements Usb{
​
    public void service(){
        System.out.println("鼠标正在工作中...");
    }
}
​
​
public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量,多态
//        Usb usb = new Mouse();
//        usb.service();
​
        //局部内部类，main方法也是方法里
//        class Fan implements Usb{
//
//            @Override
//            public void service() {
//                System.out.println("连接电脑成功，风扇开始工作...");
//            }
//        }
//
//        //使用局部内部类创建对象
//         Usb usb = new Fan();
//          usb.service();
//
​
        //使用匿名内部类优化(相当于创建了一个局部内部类)
        Usb usb = new Usb(){//第二个Usb位置可以是接口，抽象类，父类，在方法体里可以重写方法
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作...");
            }
        };
        usb.service();
    }
}
​

2、Object类

1. 超类、基类，所有类的直接或间接父类，位于继承树的最顶层；

2. 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承；

3. Object类中所调用的方法，是所有对象都基本的方法；

4. Object类型可以存储任何对

• 作为参数，可接受任何对象。

• 作为返回值，可返回任何对象。

3、Object类常用方法

3.1getClass()方法

• 　　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("居元子",999);
        Student s2 = new Student("魏元生",6);
​
        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2){
            System.out.println("s1和s2属于同一个类型");
        }else{
            System.out.println("s1和s2不属于同一个类型");
        }
​
    }
}
​

3.2hashCode()方法

• 　public int hashCode(){}
• 　返回该对象的哈希码值；
• 　哈希值根据对象的地址或字符串或数字使用hash算法（系统底层提供）计算出来的int类型的数值；
• 　一般情况下相同对象返回相同哈希码。

示例：

   Student s1 = new Student("居元子",999);
        Student s2 = new Student("魏元生",6);
        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());      //s1.hashCode()!=s2.hashCode()
        Student s3 = s1;
        System.out.println(s3.hashCode());      //s1.hashCode()=s3.hashCode()
 

3.3 toString()方法

• public String toStrin(){};
• 返回该对象的字符串表示；
• 可以根据程序需求覆盖该方法，如：展示对象各个属性的值。

 System.out.println(s1.toString());
     System.out.println(s2.toString());//默认名字+返回哈希值的十六进制

重写toString：

 @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
 

3.4equals()方法

• public boolean equals （Object obj）{}
• 默认(源码)实现为（this == obj）[比较两个对象是否相同]，比较两个对象地址是否相同；
• 可进行覆盖（重写后），比较两个对象的内容是否相同
• equals是Object类的方法，默认为比较地址，跟'=='一样，String类中重写equals方法，比较的是值。

  //判断两个对象是否相等
        System.out.println(s1.equals(s2));//false
        Student s6 = new Student("小米", 12);
        Student s7 = new Student("小米", 12);
        System.out.println(s6.equals(s7));//false

equals()方法覆盖（重写）步骤

1. 比较两个引用是否指向同一个对象；

2. 判断obj是否为null；

3. 判断两个引用指向的实际对象类型是否一致；

4. 强制类型转换；

5. 依次比较各个属性值是否相同。

//Student类里
public boolean equals(Object obj) {
        //1.判断两个对象是否是同一个引用
        if (this == obj) {
            return true;
        }
        //2.判断obj是否null
        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;
    }

tips： instanceof比较的是前面的实际类型是不是后面对象实际类型的子类或同类，是的话返回true，否则返回false，所以true的情况下要强制转换为同类

3.5finalize（）方法

　　　finalize：译：最终确定，把(计划、旅行、项目等)最后定下来;定案

1. 当对象被判定为垃圾对象时，有JVM自动调用此方法，用以标记垃圾对象，进入回收队列；

2. 垃圾对象：没有 有效引用（没有被赋予变量等） 指向此对象时，为垃圾对象；

3. 垃圾回收：由GC销毁垃圾对象，释放数据存储空间；

4. 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象；

5. 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。（说是手动，其实还是JVM自动回收，只不过是被人为的告诉JVM一声）。

//Student类里
         protected void finalize() throws Throwable{
        System.out.println(this.name+"对象被回收了...");
    }

//TestStudent类里
        new Student("aaa",32);
        new Student("bbb",32);
        new Student("ccc",32);
        new Student("ddd",32);
        new Student("eee",32);
        System.gc();
        System.out.println("回收垃圾");

2022-09-26  20:06:06