Java基础学习07--内部类与常用类

1 内部类

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

特点：

(1)编译之后可以生成独立的字节码文件。

(2)内部类可以直接访问外部类的私有成员。

(3)内部类可以为外部类提供功能组件。

 

1.1 成员内部类

把一个类定义在另一个类内部，作为实例成员。与实例变量、实例方法同级。创建内部类对象时，必须依赖外部类对象。

package javabasic.internalclass;

public class OuterClass01 {
    private String name ="zs";
    private Integer age = 20;
    
    //可以使用访问修饰符：public/private/protected
    class Inner{
        private String address = "beijing";
        private String phone = "123";
        
        private String name = "lisi";
        
        //静态内部类不能包含静态变量
        //private static String country = "zhongguo";
        
        //静态内部类里可以包含静态常量
        private static final String country = "china";
        
        public void show() {
            //内部类与外部类同名，优先访问内部属性
            System.out.println(name);
            
            //内部类与外部类同名，需要加前缀来访问外部类属性
            System.out.println(OuterClass01.this.name);
            //打印外部类的属性
            System.out.println(age);
            
            //打印内部类的属性
            System.out.println(address);
        }
    }

    public static void main(String[] args) {
        // 1.调用内部类的方法
        OuterClass01 d1 = new OuterClass01();
        d1.new Inner().show();
    }
}

 

1.2 静态内部类

把一个类定义在另一个类内部，作为静态成员。静态内部类创建时，不依赖外部类对象，可直接创建或通过类名访问，可以声明静态成员。

package javabasic.internalclass;

//2.静态内部类
public class OuterClass02 {
    
    private String name ="zs";
    private Integer age = 20;
    
    //静态内部类的级别，和外部类相同
    static class Inner{
        
        private String address = "beijing";
        private String phone = "123";
        
        private String name = "lisi";
        
        private static Integer count = 100;
        
        public void show() {
            //内部类与外部类同名，优先访问内部属性
            System.out.println(name);
            
            //内部类与外部类同名，需要加前缀来访问外部类属性
            System.out.println(new OuterClass02().name);
            //打印外部类的属性
            System.out.println(new OuterClass02().age);
            
            //打印内部类的属性
            System.out.println(address);
            
            //打印静态内部类的静态属性
            //类名.静态属性 或 直接用静态属性
            System.out.println(Inner.count);
        }
    }
    
    public static void main(String[] args) {
        // 直接
        OuterClass02.Inner inner2 = new OuterClass02.Inner();
        inner2.show();
    }
}

 

1.3 局部内部类

把一个类定义在另一个类的方法的内部，作为局部变量。作用范围和创建对象范围仅限于当前方法。

package javabasic.internalclass;

//3.局部内部类
public class OuterClass03 {

    private String name ="zs";
    private Integer age = 20;
    
    public void show() {
        //在jdk 1.8 这个局部变量会自动变为final常量，后续不能再修改
        String address = "abc";
        
        //局部内部类，不能加访问修饰符
        class Inner{
            private String name = "ls";
            private String phone="1234567";
            private String email="1@1.com";
                        
            //private static Integer newcount = 200;//不能定义静态变量
            private final static int newcount = 200;//可以定义静态常量

            public void show2() {
                //访问外部类的方法中的局部"常量"
                System.out.println(address);
                
                //访问内部类的属性
                System.out.println(name);
                System.out.println(phone);
                System.out.println(email);
                
                //访问外部类属性
                System.out.println(OuterClass03.this.name);
                System.out.println(OuterClass03.this.age);
                
            }
        }
        //在外部类的方法中，调用内部类的方法
        Inner inner = new Inner();
        inner.show2();
    }
    
    public static void main(String[] args) {
        OuterClass03 oc3 = new OuterClass03();
        oc3.show();
    }
}

 

1.4 匿名内部类

没有名字的内部类，一般用在接口/抽象类中。没有定义名字的局部内部类。

package javabasic.internalclass;

public class OuterClass04 {
    public static void main(String[] args) {
        // 1.普通调用
//        USB usb = new Mouse();
//        usb.service();
        
        // 2.使用局部内部类
//        class Fan implements USB{
//            @Override
//            public void service() {
//                // TODO Auto-generated method stub
//                System.out.println("风扇开始工作");
//            }
//        }
//        
//        USB usb = new Fan();
//        usb.service();
        
        // 3.使用匿名内部类
        USB usb = new USB() {
            @Override
            public void service() {
                // TODO Auto-generated method stub
                System.out.println("风扇开始工作");
            }
        };
        usb.service();
    }
}

 

2 Object类

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

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

(3)Object类中所定义的方法，是所有对象都具备的方法。

(4)Object类型可以存储任何对象

 

2.1 getClass()

返回此Object的运行时类。

 

2.2 hashCode()

返回该对象的hash值(内存地址)。

 

2.3 toString()

返回该对象的字符串表示。

 

2.4 equals(Object obj)

指示其他对象是否与此对象“相等”。

 

2.5 finalize()

当垃圾回收器确定不存在该对象的更多引用时，由对象的垃圾回收器调用此方法。

 

3 包装类

这些包装类定义在java.lang.*包里面。

数据的实际值存储在堆中，而在栈中存储的是这个对象的引用(堆的内存地址)。

装箱：从基本类型转换成包装类型。包装类名.valueOf()

拆箱：从包装类型转换成基本类型。实例对象.xxxValue()

jdk 1.5之后，可以自动装箱/拆箱，其内部调用了相应的方法。

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

package javabasic.internalclass;

public class demo01 {
    public static void main(String[] args) {
        // 1. 装箱与拆箱
        //装箱
        int a = 10;
        Integer A = Integer.valueOf(a);
        
        //拆箱
        a = A.intValue();
        // 在jdk 1.5 以后可以自动装箱/拆箱
        int b = 9;
        Integer B = b;//装箱
        b = B;//拆箱
        
        //2. 数字与字符串
        Integer C = 8;
        String SC = Integer.toString(C,10);//按十进制转为字符串
        System.out.println(SC);//"8"
        
        String SC2 = Integer.toOctalString(C);//将数字转为字符串，并按八进制表示
        System.out.println(SC2);//"10"
        
        Integer D = Integer.parseInt(SC2, 8);//将八进制表示的字符串以转为数字
        System.out.println(D);//8
        
        //3. Integer的缓冲区
        //Integer类型在调用valueOf()方法时，会判断数字是否在-128~127之间
        //在这个区间的数字，不会额外生成，而是从缓存中取出
        
        Integer X1 = Integer.valueOf(127);
        Integer X2 = 127;//自动装箱，底层会调用valueOf()方法
        System.out.println(X1==X2);//true
        
        Integer Y1 = Integer.valueOf(128);
        Integer Y2 = 128;
        System.out.println(Y1==Y2);//false
    }
}

 

4 String类

字符串是常量，创建之后不可改变。

字符串字面值存储在字符串池中，可以共享。 

 

4.1 length()方法

返回字符串的长度

 

4.2 charAt(int index)

根据下标获取字符

 

4.3 contains(String str)

判断当前字符串中是否包含str

 

4.4 toCharArray()

将字符串转换成数组

 

4.5 indexOf(String str)

查找str首次出现的下标，存在则返回下标，不存在则返回-1

 

4.6lastIndexOf(String str)

查找str最后一次出现的下标

 

4.7 trim()

去掉字符串前后的空格

 

4.8 toUpperCase()/toLowerCase()

将字符串转换为全大写/小写

 

4.9 startWith(String str)/endWith(String str)

判断字符串是否以str开始/结尾

 

4.10 replace(char oldChar,char newChar)

将旧字符替换成新字符

 

4.11 split(String str)

根据str做拆分

 

4.12 intern()

返回字符串对象的规范化表示形式

String a = "a";
String b = a + "b";
String c = "ab";
String d = new String(b);

System.out.println(b == c);//false
System.out.println(d == c);//false
System.out.println(c == d.intern());//true
System.out.println(b.intern() == d.intern());//true

 

5 可变字符串

5.1 StringBuilder

运行效率快，线程不安全

 

5.2 StringBuffer

运行效率慢，线程安全

 

6 BigDecimal

作用：精确计算浮点数，存储在java.math包中。

BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
BigDecimal bd3 = bd1.subtract(bd2);
System.out.println(bd3);//0.1

 

7 日期时间

7.1 Date类

package javabasic.internalclass;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo01 {

    public static void main(String[] args) {
        // 1. Date类
        Date d1 = new Date();
        System.out.println(d1);//Wed Jan 27 15:00:52 CST 2021
        System.out.println(d1.getTime());//1611731006864
        System.out.println(d1.toLocaleString());//Jan 27, 2021 3:01:29 PM
        
        Date d2 = new Date(1611731006864L);
    }
}

 

7.2 Calendar类

public class Calendar01 {

    public static void main(String[] args) {
        // 1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        
        //2.获取时间信息
        int year = calendar.get(calendar.YEAR);
        System.out.println(year);
        
        int month = calendar.get(calendar.MONTH);
        System.out.println(month);
        
        //3.修改时间
        Calendar calendar2 = calendar.getInstance();
        calendar2.set(calendar.DAY_OF_MONTH, 1);
        System.out.println(calendar2.getTime().toLocaleString());
    }
}

 

7.3 SimpleDateFormat类

package javabasic.internalclass;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo03 {

    public static void main(String[] args) {
        // 3.SimpleDateFormat
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        Date d1 = new Date();
        String strDate = sdf.format(d1);
        System.out.println(strDate);//2021-01-27 15:15:53.596
    }
}

 

8 System类

主要用于获取系统的属性和其他操作，构造方法私有的。

 

8.1 System.arrayCopy()

复制数组

 

8.2 System.currentTimeMillis()

获取时间戳

 

8.3 System.gc()

简易JVM启动垃圾回收

 

8.4 System.exit(int status)

退出jvm，参数0表示正常退出，非0表示异常退出jvm