Java学习_20220611

JAVA常见类学习

1. 内部类

概念：在一个类的内部再定义一个完整的类。

特点：（1）编译后可生成独立的字节码文件；

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

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

（1）成员内部类：在类的内部定义，与实例变量、实例方法同级别的类。

      是外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

      如果内部类、外部类中存在重名属性时，会优先访问内部类属性，此时若要访 问外部类的属性，则使用  Outer.this.name

      在内部类中不能包含静态成员，但可以包含静态常量。

private static String country="中国";//报错
private static final String country="中国";//正确

//访问内部类中的方法
Outer outer = new Outer(); //创建外部类对象
Outer.Inter inter = outer.new Inter(); //创建内部类对象
//一步到位
Outer.Inter ter = new Outer().new Inter();
inter.method();

//若在类中导入内部类所在的包 import java_basics.basClss.inClass.Outer.Inter;
//则访问时可去掉Outer ，改为 Inter ter = new Outer().new Inter();

 （2）静态内部类：static表示通过(类名.)来调用类的属性和方法

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

      内部类的等级与外部类一致，可直接访问自己的变量，但使用外部类的成员变量：1.创建外部类的实例化对象；2.调用外部类变量

//调用方法
Outer.Inter inner = new Outer.Inter();
inner.method();

 （3）局部内部类：定义在外部类的方法中，作用范围和创建对象范围进项于当前方法。不能包含static成员，但可以加上final常量。限制了类的使用范围。

public class Outer {
    private String name = "老李";
    private int age = 36;
    public void mothod(){
        String ad = "长沙";//必须为常量，final，jdk自动加了final
        class Inner{//局部内部类，不能加任何访问修饰符
            private String phone = "133";
            public void method(){
                System.out.println(Outer.this.name);//访问外部类的属性，加Outer.this.，也可直接访问
                System.out.println(age);
                System.out.println(this.phone);//访问内部类的属性
                System.out.println(ad);
            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.method();
    }
}
//调用方法
public static void main(String[] args) {
        Outer outer = new Outer();
        outer.mothod();
}

（4）匿名内部类：没有类名的局部内部类（一切特征都与局部内部类相同）

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

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

        优点：减少代码量；缺点：可读性较差

public interface Usb {
    void work();
}
//调用类
public class TestUsb {
    public static void main(String[] args) {
       /*  局部内部类
        class Mouth implements Usb{
            @Override
            public void work() {
                System.out.println("连接成功，鼠标可以工作了!");
            }
        }
        //使用局部内部类创建对象（只用一次）
        Usb usb = new Mouth();
        usb.work();*/

       //使用匿名内部类优化（相当于创建了一个局部内部类）
       Usb u = new Usb() { //可以是接口，也可以是抽象类或者父类
           @Override
           public void work() {
               System.out.println("连接成功，可以开始工作了!");
           }
       };
       u.work();
    }
}

 2. Object类

（1）getClass()方法： Class class = s.getClass();

  返回引用中存储的实际对象类型，通常用于判断两个引用中实际存储对象类型是否一致。

（2）hashCode()方法：int x = s.hasCode();

  返回该对象的哈希码值，哈希值根据对象的地址或者字符串或者数字使用hash算法计算出来的int类型的值，一般情况下相同对象返回相同的哈希码。

（3）equals()方法：s.equals(s1)

  返回布尔值，判断地址是否相同，可进行覆盖，判断内容是否相同。步骤如下：

• 比较两个引用是否指向同一个对象
• 判断obj是否为null
• 判断两个引用指向的实际对象类型是否一致Class class = s.getClass()或者obj instanceof s的实际类型
• 强制类型转换
• 依次比较各个属性值是否相同

（4）finalize()方法：回收垃圾对象。 

3. 包装类：基本数据类型所对应的引用数据类型。

八种基本类型：byte \ short \ int \ long \ char \ double \ float \ boolean

装箱：基本类型转换为引用类型（Integer inte = Integer(number)或者Integer inte = Integer.valueof(number)）自动装箱调用valueof()，在内存中保存的数是-128到127之间

拆箱：引用类型转换为基本类型（byteValue()\shortValue()\intValue()......）

 

 基本类型转换成字符串：

int n1 = 15;
String s1 = Integer.toString(n1)；
String s2 = Integer.toString(n1,16)；//n1变成16进制

字符串转换成基本类型： 

String str="150";
int n2 = Integer.parseInt(str);

4.String类（不可变性，性能低）

toCharArray();返回字符串对应的数组

String s = "Java is";
System.out.println(Arrays.toString(s.toCharArray())); //[J,a,v,a, ,i,s]

substring()截取

5.可变字符串（比String效率高，节省内存）

（1）StringBuffer：运行效率慢，线程安全

（2）StringBuilder：运行效率快，线程不安全

StringBuffer sb = new StringBuffer();
//append();追加
sb.append("2022年");
sb.append("6月");
System.out.println(sb.toString());
//insert();添加
sb.insert(0,"今天是");
System.out.println(sb);
//replace();替换
sb.replace(3,7,"1839");
System.out.println(sb);
//delete()；删除
sb.delete(2,5);
System.out.println(sb);
//清空
sb.delete(0,sb.length());
System.out.println(sb);

6.BigDecima类

double是近似值存储，BigDecima精确计算浮点数。

BigDecimal b1 =new BigDecimal("1.0");
BigDecimal b2 =new BigDecimal("0.9");
//减法 subtract()
BigDecimal r1 = b1.subtract(b2);
System.out.println(r1);
//加法 add()
BigDecimal r2 = b2.add(b1);
System.out.println(r2);
//乘法 multiply()
BigDecimal r3 = b1.multiply(b2);
System.out.println(r3);
//除法 divide()
BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
System.out.println(r4);

 7.Data()

8.Calenser()：修饰符是protected，不能直接创建该对象。