常见类和对象，异常

常见类和对象

TODO 常见类和对象
java.lang.Object : 对象

讲对象转换成字符串。
toString默认打印的就是对象的内存地址，所以，为了能够更直观理解对象的内容，所以可以重写这个方法
    
TODO 获取对象的内存地址  :     int i = obj.hashCode()

TODO 判断两个对象是否相等, 如果相等，那么返回true，否则返回false
equals方法比较对象时，默认比较就是内存地址

getClass获取对象的类型信息
    Class<?> aClass = obj.getClass();

数组

TODO 数组的声明方式：类型[] 变量；
TODO 数组的创建：new 类型[容量]；    String[] names = new String[3];

1.给数组的小格子添加数据，添加的方式为 ：数组变量[索引] = 数据
2.添加数据和访问数据时，索引是不能超过指定的范围的（0 ~ length-1）
3.如果重复给相同的索引添加数据，那么等同于修改数据
4.查询(访问)数据，访问的方式为 ：数组变量[索引]    
5.获取数组的长度   数组名.length

冒泡

        // TODO 希望获取到的数据，1，2，3，4，5
        // 简化需求：将数组中的最大值放置数组的最后
        int[] nums = {1,4,3,5,2};
        for ( int j = 0; j < nums.length; j++ ) {
            for ( int i = 0; i < nums.length - j - 1; i++ ) {
                int num1 = nums[i];
                int num2 = nums[i+1];
                if ( num1 > num2 ) {
                    // 左边的数据大于右边的数据，应该交互位置
                    nums[i] = num2;
                    nums[i+1] = num1;
                }
            }
        }

选择

       // 数组 - 选择排序
        int[] nums = {1,4,3,5,2};

        for ( int j = 0; j < nums.length; j++ ) {
            int maxIndex = 0;
            for ( int i = 1; i < nums.length - j; i++ ) {
                if ( nums[i] > nums[maxIndex] ) {
                    maxIndex = i;
                }
            }
            int num1 = nums[nums.length-j-1];
            int num2 = nums[maxIndex];

            nums[maxIndex] = num1;
            nums[nums.length-j-1] = num2;
        }

二分

        // 数组 - 数据查询 - 二分查找法
        int[] nums = {1,2,3,4,5,6,7};

        // 查询目标
        int targetNum = 6;
        int start = 0;
        int end =  nums.length - 1;
        int middle = 0;
        while ( start <= end ) {
            middle = (start + end) / 2;
            if ( nums[middle] > targetNum ) {
                end = middle - 1;
            } else if ( nums[middle] < targetNum ) {
                start = middle + 1;
            } else {
                break;
            }
        }

hashCode() 获取内存地址

字符串-查询

 TODO 拼接：将多个字符串连接在一起   + 和concat()
 String s = "a" + "b"; // "ab"
 String s1 = "ab";
 String s2 = "abc" + 1 + 2; // abc12
 String s3 = 1 + "abc" + 2; // 1abc2
 String s4 = (1 + 2) + "abc"; // 3abc

concat()方法：   s1.concat("abc")

    
TODO 字符串的比较  equals() 
    ①相等
	System.out.println(a.equals(b));
 	②忽略大小写的相等
	System.out.println(a.equalsIgnoreCase(b));
	③比较大小  compare()
        i = 正数，a > b
		i = 负数，a < b
		i = 0, a = b
        int i = a.compareTo(b);
	④忽略大小写
        a.compareToIgnoreCase(b)
        
        
TODO 字符串的截断操作 : 截取字符串的操作
    substring方法用于截取字符串，需要传递两个参数，
    第一个参数表示截取字符串的起始位置（索引，包含）  System.out.println(s.substring(0, 3));
    第二个参数表示截取字符串的结束位置（索引，不包含）  
        System.out.println(s.substring(0, "Hello".length()));
    substring方法如果只传递一个参数，那么就表示从指定位置开始截取字符串，然后截取到最后
        System.out.println(s.substring(6));
  
	分解字符串 ：根据指定的规则对字符串进行分解。可以将一个完整的字符串，分解成几个部分。 				s.split(",")
       
        
 TODO trim : 去掉字符串的首尾空格的意思
     System.out.println("!" + s.trim() + "!")

 TODO 字符串的替换。replace()
String s = "Hello World zhangsan"; // Hello Java Java
s.replace("World zhangsan", "Java")
 replaceAll按照指定的规则进行替换
System.out.println(s.replaceAll("World|zhangsan", "Java"));

 TODO 字符串的大小写转换
String s = "Hello World";
System.out.println(s.toLowerCase());// 全转换小写
System.out.println(s.toUpperCase());//全转换大写


TODO 字符串的查找
char[] chars = s.toCharArray();
byte[] bytes = s.getBytes("UTF-8");

 charAt可以传递索引定位字符串中指定位置的字符
System.out.println(s.charAt(1));

 indexof方法用于获取数据在字符串中第一次出现的位置。
System.out.println(s.indexOf("World"));

 lastIndexOf方法用于获取数据在字符串中最后一次出现的位置。
System.out.println(s.lastIndexOf("World"));

 是否包含指定的字符串，返回布尔类型
System.out.println(s.contains("Hello123"));

 判断字符串是否以指定的数据开头，返回布尔类型
System.out.println(s.startsWith("Hello"));

 判断字符串是否以指定的数据结尾，返回布尔类型
System.out.println(s.endsWith("World"));

 判断字符串是否为空，空格其实是一个特殊的字符，所以看不到，但是不为空。
System.out.println(s.isEmpty());

字符串-StringBuilder

StringBuilder : 构建字符串
    StringBuilder s = new StringBuilder();//利用数组的方式实现字符的拼接，比重新构建字符串的方式更加省时
 	for ( int i = 0; i < 100; i++ ) {
     	s.append(i);
 	}
 	System.out.println(s.toString());   toString()方法将其编程字符串
    
    s.append("abc");
    System.out.println(s.toString()); //转换成字符串
	System.out.println(s.length());// 求长度
	System.out.println(s.reverse()); // 反转字符串
	System.out.println(s.insert(1, "d"));//指定位置插入字符

基本数据类型

byte short int long  整型
float double  浮点
char   字符
boolean  布尔
    
    
TODO 包装类（引用数据类型）
Byte b = null;
Short s = null;
Integer i = null;
Long lon = null;
Float f = null;
Double d = null;
Character c = null;
Boolean bln = null;


int i = 10;
①Integer i1 = new Integer(i);  //不推荐使用
② TODO 将基本数据类型转换为包装类型
自动装箱：Integer i1 = Integer.valueOf(i); //全部写法
通常这么写就可以 ：  Integer i1 = i;


自动拆箱： int i2 = i1.intValue();  //全部写法
通常这么写就可以 ： int i2 = i1;

Date : 日期类

时间戳 ： 毫秒
    System.currentTimeMillis()
    
Date : 日期类
Calendar : 日历类
    Date d = new Date();
    System.out.println(d);

Java格式化日期格式：
y (Y) -> 年 -> yyyy
m (M) -> MM : 月份，mm:分钟
d (D) -> dd : 一个月中的日期，D：一年中的日期
h (H) -> h : 12进制， HH：24进制
s (S) -> s : 秒，S :毫秒
    
        // Date -> String
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); //将日期转化为固定的格式
        String dateFormatString = sdf.format(d);  //sdf.format(d)将当前日期格式化
        System.out.println(dateFormatString);

        // String -> Date
        String dateString = "2022-06-01";
        Date parseDate = sdf.parse(dateString);  //sdf.parse()  解析字符串成日期
        System.out.println(parseDate);

        // 根据时间戳构建指定的日期对象。
        d.setTime(System.currentTimeMillis());
        // 获取时间戳
        d.getTime();
        System.out.println(parseDate.before(d));  //测试该时间是否早于当前时间
        System.out.println(parseDate.after(d));   //测试该时间是否晚于当前时间

日历类

Calendar instance = Calendar.getInstance();  调用日历类
System.out.println(instance);  //不可取


System.out.println(instance.get(Calendar.YEAR));   //获取年
System.out.println(instance.get(Calendar.MONTH));//获取月
System.out.println(instance.get(Calendar.DATE));//获取日期

instance.add(Calendar.YEAR, -1); //当前的日历 -1年

//TODO 小测试，打印一个月份的日历
import java.util.Calendar;
import java.util.Date;

public class Date_Test {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // 打印当前日历
        System.out.println("周一\t周二\t周三\t周四\t周五\t周六\t周日");
        // 获取当前日期的日历对象
        Calendar firstDate = Calendar.getInstance();
        // 把日历对象设定位当前月的第一天 : 10-01
        firstDate.set(Calendar.DAY_OF_MONTH, 1);
        // 获取当前月最大的日期 : 31
        int maxDay = firstDate.getMaximum(Calendar.DAY_OF_MONTH);
        for ( int i = 0; i < maxDay; i++ ) {
            // 当前日期是周几
            int weekX = firstDate.get(Calendar.DAY_OF_WEEK);
            // 当前日期是几号
            int monthY = firstDate.get(Calendar.DAY_OF_MONTH);
            if ( i == 0 ) {
                if (weekX == Calendar.SUNDAY) {
                    for ( int j = 0; j < 6; j++ ) {
                        System.out.print("\t");
                    }
                    System.out.println(monthY);
                } else {
                    // 周日是1，周一是2...周六是7
                    for ( int j = 0; j < weekX - 2; j++ ) {
                        System.out.print("\t");
                    }
                    System.out.print(monthY);
                    System.out.print("\t");
                }
            } else {
                // 不是一号的场合
                if ( weekX == Calendar.SUNDAY ) {
                    System.out.println(monthY);
                } else {
                    System.out.print(monthY);
                    System.out.print("\t");
                }
            }
            // 打印日历后，应该增加一天
            firstDate.add(Calendar.DATE, 1);
        }

    }
}

工具类

在以后工作中，常用的代码可以自己封装工具类，方便我们在项目里面进行调用。

字符串工具类
1. 工具类不应该创建对象才能使用，也就意味着，可以直接使用类中的属性和方法，一般都声明为静态的。
2. 工具类对外提供的属性或方法都应该是公共的。
3. 为了使用者开发方便，应该尽量提供丰富的方法和属性
   
    
    TODO 详情见E:\~1.a 桌面\七天java\代码\chapter05\Java08_Object_Util.java

基本数据类型，双等号比较数值
引用数据类型，双等号比较变量的内存地址
包装类型:int => Integer => JVM为了操作方便，简化了很多操作  
    Integer缓存：-128 ~ 127

异常

错误

 TODO 错误
     
1. 类型转换错误
String s = "123";
Integer i = (Integer)s; //会出现错误
Integer i = Integer.parseint(s)/;  //正确写法

 2. 递归没有跳出的逻辑：java.lang.StackOverflowError
    递归
 Error : 错误
test();

3.访问一个为空对象的成员方法是，出现了错误：  java.lang.NullPointerException  (异常)
异常 ： Exception
TODO 异常的分类
3.1 可以通过代码恢复正常逻辑的异常,称之为运行期异常。（RuntimeException）
3.2 不可以通过代码恢复正常逻辑的异常,称之为编译期期异常(Exception)

异常

异常处理语法：

         TODO try :尝试
         TODO catch :  捕捉
            捕捉多个异常的时候，需要先捕捉范围小的异常，然后再捕捉范围大的异常
         TODO finally : 最终

         try {
             可能会出现异常的代码
             如果出现异常，那么JVM会将异常进行封装，形成一个具体的异常类，然后将这个异常抛出
             所有的异常对象都可以被抛出
         } catch ( 抛出的异常对象 对象引用 ) {
             异常的解决方案
         } catch () {

         } finally {
            最终执行的代码逻辑
         }



e.getMessage() // 错误的消息
e.getCause()  //错误的原因
常用：e.printStackTrace();   //打印堆栈信息，解决问题

常见异常

 1. 除数为0的算术异常:java.lang.ArithmeticException
   运行期异常
     
int i = 0;
if ( i != 0 ) {
    int j = 10 / i;
}


 2 : 空指针异常 : java.lang.NullPointerException
     调用了一个为空（null）对象的成员属性或成员方法时，就会发生异常
     
3. 索引越界 : ArrayIndexOutOfBoundsException
    数组的索引越界，可以通过修改代码完成（运行期异常）
    
4. 字符串索引越界:StringIndexOutOfBoundsException
    
5. 格式化异常：NumberFormatException
    转换数据的时候出现错误
    
6. 类型转换错误：java.lang.ClassCastException 

 TODO 异常
IOException
SocketException
SQLException
FileNotFoundException
ClassNotFoundException

TODO 异常
可以创建异常对象，并提供异常信息
可以主动抛出异常，使用关键字throw
如果方法抛出异常，那么可以使用throws关键字明确方法会抛出异常

如果方法中可能会出现问题，那么需要提前声明，告诉其他人，我的方法可能会出问题。
此时需要使用关键字throws
如果程序中需要手动抛出异常对象，那么需要使用throw关键字，然后new出异常对象
    
eg:
public void test( int i, int j ) throws Exception {
        try {
            System.out.println( i / j);
        } catch (ArithmeticException e) {
            throw new Exception();
        }

    }