java基础之常用类1

  • 作者:逝去の年华
  • 分类: java

 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. 

  2. 

    判断obj是否为null；
    

    3. 

  3. 

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

    4. 

  4. 

    强制类型转换；
    

    5. 

  5. 

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

    6. 





//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. 

  2. 

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

    3. 

  3. 

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

    4. 

  4. 

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

    5. 

  5. 

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

    6. 





//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


 


 


 


 


 


 


 


 


 


 

转载自: https://www.cnblogs.com/lyh1024/p/16732224.html
                                    

                                        
标签