常用类

内部类

分类

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

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

class Outer{
	class Inner{
        
    }
}

特点：

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

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Body {
    private String body = "身体";
    class Header{
        
        public void show(){
            System.out.println(body);
        }
    }
}

成员内部类

在类的内部定义，与实例变量，实例方法同级别的类
内部类是外部类的一个实例部分，创建内部类时，必须依赖外部类对象
```
Outer out = new Outer();
Inner in = out.new Inner();
```
当外部类、内部类存在重名属性时，会优先访问内部类属性
成员内部类不能定义静态成员(属性)，但能包含静态常量

package OOP.commonClass;
import OOP.commonClass.Outer.Inner;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Test {
    public static void main(String[] args) {
        //1、创建外部类对象
        Outer body = new Outer();
        //2、创建内部类对象
        Inner inner = body.new Inner();

        //一步到位
        Inner inner1 = new Outer().new Inner();
        
        inner.show();
        inner1.show();
    }
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
//外部类
public class Outer {
    private String body = "身体";
    private int length = 100;
    //成员内部类
    class Inner{
        private int age = 18;
        private final int high = 11;
        //属性和外部类属性名字相同
        private int length = 50;
        public void show(){
            //访问外部类成员
            System.out.println(body);
            //内部类和外部类属性重名，使用 外部类名.this.属性 来访问
            System.out.println(Outer.this.length);
            //访问内部类成员
            System.out.println(age);
            System.out.println(length);
        }
    }
}

静态内部类

不依赖外部对象，可直接创建或提供类名访问，可声明静态成员
只有内部类才能用static修饰

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
//外部类
public class Outer {
    private String body = "身体";
    private int length = 100;
    //静态内部类，级别和外部类相同
    static class Inner{
        private int age = 18;
		//静态成员
        private static int count = 10000;
        public void show(){
            //访问外部类成员
            //1、先创建外部类对象
            Outer out = new Outer();
            //2、调用外部类对象属性
            System.out.println(out.body);
            System.out.println(out.length);
            //访问内部类成员
            System.out.println(age);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Test {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}

局部内部类

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

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
//外部类
public class Outer {
    private String body = "身体";
    private int length = 100;

    //若为静态方法，则不能访问外部类属性
    public void show(){
        //定义局部变量
        String address = "桂林";
        //不能有静态变量，但能有静态常量final
        //private static int count = 10000;
        private final static int count = 10000;

        //局部内部类：注意不能加任何访问修饰符
        class Inner{
            //局部内部类属性
            public String phone = "111111";
            private int id = 111;

            public void print(){
                //访问外部类的属性
                System.out.println(Outer.this.body);
                System.out.println(Outer.this.length);
                //访问内部类的属性
                System.out.println(phone);
                System.out.println(id);
                //访问局部变量，jdk1.7要求：变量必须是常量final   jdk1.8自动添加final
                System.out.println(address/*相当于直接打印  "桂林"  */);
                // 等价于 System.out.println("桂林");
            }
        }
        //需要在方法里 创建内部类对象，调用内部类对象的方法
        Inner inner = new Inner();
        inner.print();
    }
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Test {
    public static void main(String[] args) {
        //创建外部类对象
        Outer outer = new Outer();
        outer.show();
    }
}

匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）
必须继承一个父类或实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优点：减少代码量
缺点：可读性差

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Test {
    public static void main(String[] args) {
        //创建接口类型的变量
        /*UserService user = new User();
        user.service();*/

        //局部内部类
        /*class User1 implements UserService{
            @Override
            public void service() {
                System.out.println("实现用户1服务接口");
            }
        }
        UserService user = new User1();
        user.service();*/

        //匿名内部类优化（相当于创建了一个局部内部类）可再优化为lambda表达式
        UserService user = new UserService() {
            @Override
            public void service() {
                System.out.println("实现用户2服务接口");
            }
        };
        user.service();
        //lambda
        UserService user =()->{  System.out.println("实现用户3服务接口");};
        user.service();
    }
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public interface UserService {
    //服务
    void service();
}

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class User implements UserService{
    @Override
    public void service() {
        System.out.println("实现用户服务接口");
    }
}

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层
任何类，如没有书写extends显示继承某个类，都默认直接继承0bject类，否则为间接继承
Object类中所定义的方法，是所有对象都具备的方法
Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象

包装类

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

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

类型转换与装箱、拆箱

基本类型 --->引用类型装箱
引用类型 --->基本类型拆箱

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转换成引用类型的过程
        //基本类型
        int num1 = 100;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);

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

        //JDK1.5后，提供自动装箱和拆箱
        int num3 = 50;
        //自动装箱
        Integer integer4 = num3;
        System.out.println("自动装箱"+ integer4);
        //自动拆箱
        int num4 = integer4;
        System.out.println("自动拆箱"+ num4);

    }
}

8种包装类提供不同类型间的转换方式：
- Number父类中提供的6个共性方法
- parseXXX()静态方法
注意：需保证类型兼容，否则抛出NumberFormatException异常

//基本类型和字符串之间转换
//1 基本类型转字符串
int n1 = 188;
//1.1 使用+号
String s1 = n1 + "";
//1.2 使用Integer中的toString()方法
String s2 = Integer.toString(n1);
//toString重载 转换进制
String s3 = Integer.toString(n1,16);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);

//2字符串转基本类型
String str = "166";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
System.out.println(n2);

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

整数缓冲区

Java预先创建了256个常用的整数包装类型对象
在实际应用中，对已创建的对象进行复用

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        Integer i1 = new Integer(100);
        Integer i2 = new Integer(100);
        //比较的是i1和i2指向的地址，不是数值
        System.out.println(i1 == i2);//false

        Integer i3 = Integer.valueOf(100);
        Integer i4 = 100;
        //实际上自动装箱成 Integer i3 = Integer.valueOf(100);
        //   valueOf创建对象 会判断数值大小，在-128 -- 127之间，会使用预先创建的包装类型对象，进行复用
        //   本例中i3 和 i4 都是100，都会指向 整数缓冲区中值100的那个对象
        System.out.println(i3 == i4);//true

        Integer i5 = 200;
        Integer i6 = 200;
        //数值为200，超过127，所以创建了新的对象，不是复用整数缓冲区的对象
        System.out.println(i5 == i6);//false
    }
}

String类

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

package OOP.commonClass;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        String name = "hello";//存储在字符串池中
        name = "zhangsan";//“zhangsan” 赋值给name变量，给字符串赋值时，没有修改数据，
                          // 而是在开辟一个空间存放“zhangsan”，并且name指向“zhangsan”
        String name2 = "zhangsan";//如果字符串池中有“zhangsan”，则直接指向它

        //另一种创建方式， 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
    }
}

常用方法

public int length()：返回字符串的长度
public char charAt(int index)：根据下标获取字符
public boolean contains(String str)：判断当前字符串中是否包含str
public char[] toCharArray()：将字符串转换成数组
public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引
public String trim()：去掉字符串前后的空格
public String toUpperCase()：将小写转成大写
public boolean endWith(String str)：判断字符串是否以str结尾
public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
public String[] split(String str)：根据str做拆分
equals()：比较内容是否相同
- equalsIgnoreCase()：比较时忽略大小写
compareTo()：比较字符在字典里的位置

案例：

package OOP.commonClass;

import java.util.Arrays;
import java.util.Locale;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        String str = "this is a text";
        //1
        String[] arr = str.split(" ");
        for (String s : arr) {
            System.out.println(s);
        }
        //2
        String replace = str.replace("text", "practice");
        System.out.println(replace);
        //3
        str.replace("text", "easy text");
        //4
        String str1 ="";
        for (String s : arr) {
            char first = s.charAt(0);
            char upperCase = Character.toUpperCase(first);
            //substring(下标);获得从下标开始的后面的字符串
            str1 = str1 + upperCase + s.substring(1)+ " ";
        }
        System.out.println(str1);
    }
}

可变字符串

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

和String的区别：

效率比String高
比String省内存

package OOP.commonClass;

import java.util.Arrays;
import java.util.Locale;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        //StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();
        //1 append(); 追加
        sb.append("Hello World");
        System.out.println(sb.toString());
        sb.append("Hello java");
        System.out.println(sb.toString());
        //2 insert(); 添加
        sb.insert(0,"I am first");
        System.out.println(sb.toString());
        //3 replace();  替换
        sb.replace(0,10,"I am second");
        System.out.println(sb.toString());
        //4 delete();
        sb.delete(0,5);
        System.out.println(sb.toString());
        //5 清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

BigDecimal类

位置：java.math包
作用：精确计算浮点数
创建方式：BigDecimal bd = new BigDecimal("1.0");
方法：
- BigDecimal add (BigDecimal bd) 加
- BigDecimal subtract(BigDecimal bd) 减
- BigDecimal multiply(BigDecimal bd) 乘
- BigDecimal divide(BigDecimal bd) 除
  
  除不尽时使用：
  - 除法: divide (BigDecimal bd, int scal, RoundingMode mode)
  - 参数scal ：指定精确到小数点后几位
  - 参数mode ：
    - 指定小数部分的取舍模式，通常采用四舍五入的模式
    - 取值为 BigDecimal.ROUND_HALF_UP

package OOP.commonClass;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Locale;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);
        //加法
        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);

        //除不尽 ROUND_HALF_UP 四舍五入
        BigDecimal r6 = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
        System.out.println(r6);
    }
}

Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
时间单位
- 1秒=1000毫秒
- 1毫秒=1000微秒
- 1微秒=1000纳秒

Calendar类

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

package OOP.commonClass;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Locale;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) {
        //1 创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime());
        //2 获取时间信息
        //Year
        int year = calendar.get(Calendar.YEAR);
        //month 从0-11 实际的要加上1
        int month = calendar.get(Calendar.MONTH);
        //day
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        //hour
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        //minute
        int minute = calendar.get(Calendar.MINUTE);
        //second
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);
        //修改时间
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar1.getTime().toLocaleString());
        //add方法修改时间
        calendar1.add(Calendar.HOUR,1);
        System.out.println(calendar1.getTime().toLocaleString());
        //补充 获得最大和最小日期
        int maximum = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        System.out.println(maximum);
        int minimum = calendar1.getMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(minimum);
    }
}

SimpleDateFormat类

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

package OOP.commonClass;

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

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args) throws ParseException {
        //1 创建SimpleDateFormat对象 y 年 M 月 d 日 H 小时 m 分 s 秒
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss", Locale.CHINA);
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日");
        //创建Date
        Date date = new Date();
        //格式化Date
        String str = sdf.format(date);
        System.out.println(str);

        //解析 字符串 -> 日期
        //parse()里格式要和上面规定的对应 不对应的话就报错
        //如下面这一句就会报错
        Date parse = sdf.parse("1990年6月8日");
        //这句不会报错
        Date parse1 = sdf1.parse("1990年6月8日");
        System.out.println(parse.toLocaleString());
        System.out.println(parse1.toLocaleString());
    }
}

System类

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

package OOP.commonClass;


import java.util.Arrays;

/**
 * @version: java version 1.8
 * @Author: 14
 */
public class Demo {
    public static void main(String[] args)  {
        //复制
        //src：源数组
        //srcPos：从哪个位置开始复制 0
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int[] dest = new int[10];
        System.arraycopy(arr,0,dest,0,arr.length);
        //Arrays.copyOf(Original,newLength)也是调用System.arraycopy()
        System.out.println(Arrays.toString(dest));

        //获取时间
        long r = 0;
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            for (int j = 0; j < 1000000000; j++) {
                r = i+j;
            }
        }
        System.out.println(r);
        long endTime = System.currentTimeMillis();
        System.out.println("用时：" + (endTime - startTime)+"ms");

        //System.gc(); 告诉垃圾回收器回收
        new Student(18,"aaa");
        new Student(19,"bbb");
        new Student(20,"ccc");
        System.gc();
        
        //退出jvm
        System.exit(0);
        
    }
}

总结

内部类：
- 在一个类的内部再定义一个完整的类
- 成员内部类、静态内部类、局部内部类、匿名内部类
Object类：
- 所有类的直接或间接父类，可存储任何对象
包装类：
- 基本数据类型所对应的引用数据类型，可以使0bject统一所有数据
String类：
- 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享
BigDecimal类：
- 可精确计算浮点数
Date类
- 特定时间
Calendar类
- 日历
SimpleDateFormat类
- 格式时间
System
- 系统类

posted @ 2024-07-09 00:36 十四2001 阅读(1) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

常用类

常用类

内部类

成员内部类

静态内部类

局部内部类

匿名内部类

Object类

包装类

类型转换与装箱、拆箱

整数缓冲区

String类

可变字符串

BigDecimal类

Date类

Calendar类

SimpleDateFormat类

System类

总结

公告