常用类

1.内部类

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

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

特点：

编译之后可以生成独立的字节码文件。（Body&Header.class）
内部类可直接访问外部类的私有成员，而不破坏封装。
可为外部类提供必要的内部功能组件。

1.成员内部类

在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
当外部类、内部类存在重名时，会优先访问内部类属性
成员内部类不能定义静态成员（static），但是可以定义静态常量（static final）

package com.commonclass.demo01;

public class Body {
    private String name="张三";
    private int age=18;
    //内部类
    class Header{
        //实例变量
        private String address = "绍兴";
        private String phone = "110";
        //
        private String name = "李四";
        //private static final String country = "中国";

        public void show(){
            //打印外部类的属性，如果内部类属性和外部类的属性名字相同Body.this.name
            System.out.println(Body.this.name);
            System.out.println(age);
            //打印内部类的属性
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

package com.commonclass.demo01;

public class Test {
    public static void main(String[] args) {
        //1.创建外部类对象
        //Body body = new Body();
        //2.创建内部类对象
        //Body.Header header = body.new Header();
        //可以写成一句话：
        Body.Header header = new Body().new Header();
        header.show();
    }
}

2.静态内部类

不依赖外部类对象，可以直接创建或通过类名访问，可声明静态成员
只能直接访问外部类的静态成员（实例成员需要实例化外部类对象）

package com.commonclass.demo02;

//外部类
public class Outer {
    private String name = "xxx";
    private int age = 18;

    //静态内部类:级别与外部类相同
    static class Inner{
        private String address = "上海";
        private String phone = "111";
        //静态成员
        private static int count = 1000;

        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);
        }

    }
}

package com.commonclass.demo02;

public class Test {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        //调用方法
        inner.show();
    }
}

3. 局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
限制类的使用范围

package com.commonclass.demo03;

//外部类
public class Outer {
    private String name = "yehuan";
    private int age = 18;

    public void show(){
        //局部变量
        String address = "深圳";

        //局部内部类:不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "123456";
            private String email = "yehuan@qq.com";

            public void show2(){
                //访问外部类的属性
                System.out.println(Outer.this.name);
                System.out.println(Outer.this.age);
                //访问内部类的属性
                System.out.println(phone);
                System.out.println(email);
                //访问局部变量，jdk1.7要求：变量必须是常量final，jdk1.8自动添加final
                System.out.println(address);
            }

        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

package com.commonclass.demo03;

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

4.匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）
必须继承一个父类或者实现一个接口

接口：

package com.commonclass.demo04;

public interface Usb {
    //服务
    void service();
}

package com.commonclass.demo04;

public class Mouse implements Usb{
    @Override
    public void service() {
        System.out.println("连接电脑成功，鼠标开始工作");
    }
}

package com.commonclass.demo04;

public class Test {
    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类型可以存储任何对象。
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象

1.getClass()方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用：通常用于判断两个引用中实际存储对象类型是否一致

例子：

package com.object.demo01;

public class Student {
    private String name;
    private int age;

    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;
    }
}

package com.object.demo01;

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",22);
        //判断s1和s2（对象）是不是同一个类型
        Class class1 =  s1.getClass();
        Class class2 =  s1.getClass();
        if(class1 == class2){
            System.out.println("s1和s2属于同一类型");
        }else {
            System.out.println("s1和s2不属于同一类型");
        }
    }
}

2.hashCode()方法

public int hashCode(){}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
一般情况下相同对象返回相同哈希码
可以用hashCode（）判断两个对象是否是同一个。

//hashCode方法
System.out.println(s1.hashCode());

System.out.println(s2.hashCode());
Student s3 = s1;
System.out.println(s3.hashCode());

3.toString()方法

public String toString(){}
返回该对象的字符串表示（表现形式）。

可以根据程序需求覆盖该方法，如：展示对象各个属性值（通过重写toString）

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

//toString方法
System.out.println("===========toString方法============");

System.out.println(s1.toString());
System.out.println(s2.toString());

4.equals()方法

public boolean equals（Object obj）{}
默认实现为（this == obj），比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同

//equals方法:判断两个对象地址是否相等
System.out.println("===========equals方法============");
System.out.println(s1.equals(s2));

1.equals()方法覆盖步骤

比较两个引用是否指向同一个对象
判断obj是否为null
判断两个引用指向的实际对象类型是否一致
强制类型转换
依次比较各个属性值是否相同

 @Override
    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;
    }

5.finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效的引用指向此对象，为垃圾对象
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用System.gc()：通知JVM执行垃圾回收

3.包装类

栈：存放基本数据类型堆：存放引用类型

基本数据类型所对应的引用数据类型
Object可统一所有数据，包装类的默认值是null

包装类对应：

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

1.类型转换与装箱、拆箱

装箱：把基本数据类型转换为引用类型，拆箱则相反

8种包装类提供不同类型间的转换方式

Number父类种提供的6个共性方法

package com.packageclass.demo01;

public class demo01 {
    public static void main(String[] args) {
//        int num = 10;
        //类型转换：装箱，基本类型转成引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        //Integer integer1 = new Integer(num1);//已被舍弃
        Integer integer1 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);

        //类型转换：拆箱，引用类型转成基本类型
        Integer integer2 = Integer.valueOf(100);
        int num2 = integer2.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //jdk1.5之后，提供自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer3 = age;
        System.out.println("自动装箱");
        System.out.println(integer3);
        //自动拆箱
        System.out.println("自动拆箱");
        int age2 = integer3;
        System.out.println(age2);

    }
}

parseXXX()静态方法

//2.字符串转成基本类型

String str = "150";
//使用Integer.parseXXX()方法
int n2 = Integer.parseInt(str);
System.out.println(n2);

//boolean字符串形式转成基本类型，“true”-->true 非"true"-->false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);

valueOf()静态方法
注意：需要保证类型兼容，否则抛出NumberFormatException异常

2.整数缓存区

Java预先创建了256个常用的整数包装类型

在实际应用中，对已创建的对象进行复用。

package com.packageclass.demo02;

public class demo01 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);//false  因为引用类型比较的是地址

        Integer integer3 = Integer.valueOf(100);//自动装箱 Integer.valueOf
        Integer integer4 = 100;
        System.out.println(integer3 == integer4);//true

        Integer integer5 = 200;//自动装箱
        Integer integer6 = 200;
        System.out.println(integer5 == integer6);//false
    }
}

integer3和integer4为什么是相同的？

因为自动装箱的本质是Integer.valueOf()在valueOf中已创建-128~127的数组对象故在这个区间范围内是对已创建的对象进行复用

而超出这个范围会新实例化一个对象故integer5和6是false

4.String类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享
String s = "hello"; 产生一个对象，字符串池中存储
String s = new String（“Hello”）；产生两个对象，堆和池中各存储一个

package com.packageclass.demo03;

public class demo01 {
    public static void main(String[] args) {
        String name = "hello";//"hello"常量存储在字符串池中，
        name = "zhangsan";//"zhangsan"赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间（不可变性）

        //演示字符串的另一种创建方式,new String();
        String str = new String("Java");
        String str2 = new String("Java");
        System.out.println(str == str2);//false
        System.out.println(str.equals(str2));//true
    }
}

String常用方法

public int length（）：返回字符串长度。
public char charAt（int index）：根据下标获取字符

public boolean contains（String str）：判断当前字符串中是否包含str

//字符串方法的使用
//length();返回字符串的长度
//charAt(int index);返回某个位置的字符
//contains(String str);判断是否包含某个子字符串

String content = "Java是世界上最好的语言";
System.out.println(content.length());//13
System.out.println(content.charAt(content.length()-1));//言
System.out.println(content.contains("Java"));//true
System.out.println(content.contains("php"));//false

public char[] toCharArray():将字符串转换成数组
public int indexOf（String str）：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1。
public int lastIndexOf（String str）：查找字符串在当前字符串中最后一次出现的下标索引

//toCharArray();返回字符串对应的数组
//indexOf();返回子字符串首次出现的位置
//lastIndexOf();返回子字符串最后一次出现的位置
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("Java"));//0
System.out.println(content.lastIndexOf("Java"));//13
System.out.println(content.indexOf("Java",4));//11

public String trim（）：去掉字符串前后的空格
public String toUpperCase（）：将小写转成大写
public boolean endWith（String str）：判断字符串是否以str结尾

//trim(); 去掉字符串前后的空格
//toUpperCase();把小写转成大写 toLowerCase();把大写转成小写
//endWith(str);判断是否以str结尾,startWith(str);判断是否以str开头
String content2 = "  hello  World   ";
System.out.println(content2.trim());
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
String filename = "hello.java";
System.out.println(filename.endsWith(".java"));
System.out.println(filename.startsWith("hello"));

public String replace（char oldChar，char newChar）：将旧字符串替换成新字符串
public String[] split（String str）：根据str做拆分

//replace(char old,char new); 用新的字符或字符串替换旧的字符或字符串
//split();对字符串进行拆分
System.out.println(content.replace("Java","php"));
String say = "java is the best   programing language,java xiang";
String[] arr = say.split("[ ,]+");
System.out.println(arr.length);
for (String s : arr){
    System.out.println(s);
}

System.out.println("================================");
//补充两个方法equals、compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写的比较//true

String s3 = "abc";//97
String s4 = "xyz";//120
System.out.println(s3.compareTo(s4));//-23

String s5 = "abc";
String s6 = "abcxyz";
System.out.println(s5.compareTo(s6));//-3 这个时候比的是长度

案例：

package com.packageclass.demo03;

/*
* 已知String str = "this is a text";
* 1.将str中的单词单独获取出来
* 2.将str中的text替换为practice
* 3，在text前面插入一个easy
* 4.将每个单词的首字母改为大写
* */
public class demo02 {
    public static void main(String[] args) {
        String str = "this is a text";
        //将str中的单词单独获取出来
        String[] arr = str.split(" ");
        for(String s : arr){
            System.out.println(s);
        }
        System.out.println("===============================");
        //将str中的text替换为practice
        String str2 = str.replace("text","practice");
        System.out.println(str2);
        System.out.println("===============================");
        //在text前面插入一个easy
        String str3 = str.replace("text","easy text");
        System.out.println(str3);
        System.out.println("===============================");
        //将每个单词的首字母改为大写
        for (int i = 0 ; i < arr.length ; i++){
            char first =arr[i].charAt(0);
            char upperfirst = Character.toUpperCase(first);
            String news = upperfirst + arr[i].substring(1);//substring(start，end);从第几个字符截取到第几个字符
            System.out.println(news);
        }


    }
}

可变字符串

两者功能是一样的

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
StringBuilder：可边长字符串，JDK5.0提供，运行效率快、线程不安全

package com.packageclass.demo04;

/*
*   StringBuffer和StringBuilder的使用
*   和String的区别（1）效率比String要高（2）比String节省内存
* */
public class demo01 {
    public static void main(String[] args) {
        //1 append();追加
        StringBuffer sb = new StringBuffer();
        sb.append("java世界第一");
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());
        sb.append("java不错");

        //2 insert(); 添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());
        //3 replace(); 指定位置替换
        sb.replace(0,5,"hello");//含头不含尾
        System.out.println(sb.toString());
        //4 delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());
        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.toString());

    }
}

验证StringBuilder效率高于String：

package com.packageclass.demo04;

/*
*   验证StringBuilder效率高于String
*
* */
public class demo02 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
//        String str ="";
//        for (int i =0;i<99999;i++){
//            str += i;
//        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
                sb.append(i);
        }
        System.out.println(sb.toString());
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));
    }

}

BigDecimal

很多实际应用中需要精确运算。而double是近似值存储，不符合要求需要借助BigDecimal。

位置：java.math包中
作用：精确计算浮点数
创建方式：BigDecimal bd = new BigDecimal("1.0")；

package com.packageclass.demo05;

import java.math.BigDecimal;

public class demo01 {
    public static void main(String[] args) {
        //因为double 存储的是一个近似值
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);//0.09999999999999998

        //BigDecimal，大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);//0.1

        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);

        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);

        //除法
        BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(r4);

        BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);//保留两位小数，最后的是模式（四舍五入）
        System.out.println(r5);
    }
}

5.Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法取代

package com.date;

import java.util.Date;

public class demo01 {
    public static void main(String[] args) {
        //1.创建Date对象

        //今天的时间
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        //昨天的时间
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
        //2.方法after before
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //比较 compareTo();
        int d = date1.compareTo(date2);
        System.out.println(d);//1
        //比较是否相等equals();
        boolean b3 = date1.equals(date2);
        System.out.println(b3);
    }
}

6.Calendar类

Calendar提供了获取或设置各种日历字段的方法
构造方法：
- protected Calendar()：由于修饰符是protected，所以无法直接创建该对象。

package com.date;

import java.util.Calendar;

public class demo02 {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toString());
        //获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //月
        int mouth = calendar.get(Calendar.MONTH);
        //日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        //小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(mouth+1)+"月"+day+"日"+hour+":"+minute+":"+second);
        //修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.MONTH, 5);
        System.out.println(calendar2.getTime().toString());

        //add方法修改时间
        calendar2.add(Calendar.HOUR,-1);
        System.out.println(calendar2.getTime().toString());

        //补充方法
         int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
         int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(min);
        System.out.println(max);
    }
}

7.SimpleDateFormat类

SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期->文本）、解析（文本->日期）
常用的时间模式字母：

字母	日期或者时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	1天中小时数（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	367

package com.date;

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

public class demo03 {
    public static void main(String[] args) throws Exception {
        //创建SimpleDateFormat对象 y年 M 月
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //创建Date
        Date date = new Date();
        //格式化date(把日期转成字符串)
        String str = sdf.format(date);
        System.out.println(str);
        //解析（把字符串转成日期）
        Date date2 =sdf.parse("2001年08月31日 10:20:30");
        System.out.println(date2);
    }
}

8.System类

System系统类，主要用于获取系统的属性数据和其它的操作，构造犯法私有的。

package com.System;

public class demo01 {
    public static void main(String[] args) {
        //arraycopy:数组的复制
        //src:源数组
        //srcPos:从那个位置开始复制 0
        //dest：目标数组
        //destPos:目标数组的位置
        //length：复制的长度
        int[] arr ={20,18,15,8,35,26,45,90};
        int[] dest = new int[8];
        System.arraycopy(arr,0,dest,0,arr.length);
        for (int i : dest) {
            System.out.println(i);
        }
        //Arrays.copyOf(original,newLength)

        System.out.println(System.currentTimeMillis());

        long start = System.currentTimeMillis();
        int num = 0;
        for (int i= 0;i<99999;i++){
            num = num+i;
        }
        System.out.println(num);
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start));

        //System.gc();告诉垃圾回收器回收

        //退出JVM
        System.exit(0);
        System.out.println("程序结束了");


    }
}

posted @ 2025-02-09 21:53 昼冷夜欢阅读(20) 评论(0) 收藏举报

刷新页面返回顶部

昼冷夜欢

常用类

常用类