Java面向对象（第三章异常和Object类）

最新推荐文章于 2024-05-09 20:52:43 发布

软件2201谢佩霖

最新推荐文章于 2024-05-09 20:52:43 发布

阅读量66

点赞数

文章标签： java 开发语言笔记

本文链接：https://blog.csdn.net/a_fiv/article/details/133842358

版权

Java中的异常

异常的相关概念：（笔记chap9）
           Java在运行过程中或编译过程中，难免会出现一些报错，导致程序运行的中断，
           这些报错其实指的就是异常。

           所以我们需要如何解决这些错误，也就是如何解决异常。
           更需要看到报错信息，能够快速找到异常出现的位置，然后将它修改。

异常的分类：

第一级类：Java中所有异常或错误的顶级父类都是：Throwable类。

           第二级类：其中Throwable分为错误-error和异常-exception 两大类

           error 指的是：错误，无法通过代码解决的错误。
           exception指的是：异常，可以解决的错误。


           第三级类：error下的子类都叫做XxxError 和 exception下的子类都叫做XxxException

           异常又分为两大类：运行时异常和编译时异常。
           运行时异常：指的是运行过程中才出现的异常。
           编译时异常：指的是编译过程中就出现了异常。

           编译过程：理解为代码写完后都没运行，就报错。

Error详解：

一般是程序中较严重的出错，是虚拟机层面的异常，一旦发生将会导致系统崩溃，+
无法由程序自身处理，只能通过修改虚拟机的设置，理解为修改虚拟机的相关参数，例如内存大小等。

           例如以下代码就会出现内存溢出错误。：
           int arr [] = new int[1000000000];
           System.out.println(arr.length);

           OutOfMemoryError：又称OOM，表示内存溢出错误，通常发生在内存泄露或内存不足的情况。

面试题：
           java的运行本质在运行在虚拟机的内存中。

           内存溢出的相关概念：如果程序占用的内存超过了虚拟机的剩下内存，就会出现该错误。

           内存泄漏的相关概念：虚拟机特点自动垃圾回收，但是某些垃圾无法回收。例如Scanner类,需要手动了去close。
           但是如果没有手动的close。那么该对象就会长期占据内存。长期以往，内存也会慢慢的溢出、

Exception详解：

Java中最常出现的就是异常，俗称BUG，没有没有BUG的程序，如果某个程序没有BUG，那么说明这个程序是个垃圾程序。

常见的运行时异常：

空指针异常（NullPointException）
           数组越界异常（ArrayIndexOutOfBoundsException）
           数字格式化异常（NumberFormatException）
           算数运算符异常（ArithmeticException）

           一般来说：
           运行时异常不用去特意处理，而是通过仔细编写代码来避免这些异常。

       //空指针异常（NullPointException）
       //指的就是某个对象是null。你还去调用它的属性或方法。
//       String str = null;
//       System.out.println(str.length());
//

//       数组越界异常（ArrayIndexOutOfBoundsException）
//       获取的元素下标超过了数组原有的最大长度
//       int a[] = {1,2,3,4};
//       System.out.println(a[4]);


//       NumberFormatException 数字解析溢出
//       将非数字的字符串解析成数字
//       String str = "12/345";//假设用户从前台输入的这个数量后台只能通过String接受
//       int num = Integer.parseInt(str);//将字符串转成数字
//       System.out.println(num);

//       算数运算符异常（ArithmeticException）

       System.out.println(1/0);


//       一般来说：
//       运行时异常不用去特意处理，而是通过仔细编写代码来避免这些异常。

编译时异常：

还没运行就报错了，根本就不让你运行
           由于知识点的局限性，导致13章才能解除到大量的编译时异常。
           暂时就以Class.forName("xxx");作为代替。
           上述代码的意思：加载指定的类。
           例如：常见面试题：获取对象的几种方式：
           1.通过new来获取
           2.Class.forName
           3.Object中的clone方法
           4.序列化

//        Class.forName("com.yyzy.test.Stud1ent");
        a1();

以上代码就是典型的编译异常、
           需要去解决：解决的方式分为2种推荐用第二种
           1.抛异常（甩锅）
               直接在异常代码所在的方法的尾巴后面加上 throws XxxException 一般来说就加个throws Exception
               甩锅：谁调用它，谁去解决它，如果是Main方法调用，则不解决了。


           2.抓异常(当场解决)
               详情见Demo4

//如何抓异常（当场解决）语法如下：

try{
               可能出现异常的代码;
           }catch (可能出现的异常类变量名){
               哪一行如果出现了异常就立即进入这里而非报错;
           }

       */

//       try {
//           System.out.println("我没有出现异常");
//           Class.forName("com.yyzy.test.Student");
//       }catch(Exception abc) {
//           System.out.println("我是异常出现了");
//       }

//抓异常的升级版

try{
               可能出现异常的代码;
           }catch (可能出现的异常类变量名){
               哪一行如果出现了异常就立即进入这里而非报错;
           }finally{
               不管有没有出异常，都要执行这里，
           }

Scanner sc = new Scanner(System.in);
//		System.out.println("请输入你的id");
//		try {
//			int id = sc.nextInt();
//			System.out.println("你的id为" + id);
//			
//		}catch(Exception e) {//衍生： 如果想要知道异常的具体信息，可以通过
        e.getMessage获取即可
//			System.out.println("你输入的数字格式有误" + e);
//		}finally {
//			sc.close();
//			System.out.println("sc成功关闭");
//		}
		
		
		
		//衍生： try和catch的关系：
		//如果想对catch的异常进行分类，可以出现多个catch
		
//		try {
//			String str = null;
//			System.out.println(str.length());
//			int a = 1/0;
//		}catch (NullPointerException e) {
//			System.out.println("空指针报错了");
//		}catch (ArrayIndexOutOfBoundsException e) {
//			System.out.println("数组下标异常进入这里");
//		}catch (NumberFormatException e) {
//			System.out.println("数字解析异常");
//		}
		
		
		
//		//说明try后面可以不跟catch
//		try {
//			System.out.println(1);
//		}finally {
//			System.out.println(2);
//		}
//		
		
		//说明try不能单独使用，要么跟catch一起 要么跟finally一起
//		try {
//			System.out.println(1);
//		}

		
		//catch和finally必须要结合try使用
//		catch(Exception e) {
//			
//		}finally {
//			
//		}

Object类

（不会查看chap10）

Object类是Java中所有类的父类，所以Object下的方法同时也是所有类的共有方法，
       即使是你自定义的一个类，也拥有Object的方法。
       所以需要掌握Object类下的常见方法：
       1.equals方法
           a.equals(b);//其中a和b都要是一个对象而非一个基本数据类型或一个类。
           含义：判断两个对象是否为同一个对象(内存地址是否相等，本质就是==)，返回一个boolean值。
           凡是new出来的不可能是同一个对象。


       2.toString方法

   public static void main(String[] args) {
       Student s1 = new Student(1, "张三", 12);
       Student s2 = new Student(1, "张三", 12);
       boolean b = s1.equals(s2);
       System.out.println(b);
       //注意上述s1和s2即使每个属性值都一样，但是依然返回false，原因就是都是new出来的。
       //注意：如果需要在某些特定场景，equals不是判断内存地址，而是判断id如何实现。

Object常见方法： toString

总结0：直接打印对象，和打印对象的.toString方法效果是一样的一般都是省略
总结1：Object的toString打印：对象的内存地址，格式：路径+ @ + 内存地址

           如果存在某个场合，希望打印的是具体属性信息而非地址，则可以通过重写toString方法实现。
           大部分的实体类都会重写toString，原因：方便阅读实体对象是否符合要求

==和equals的区别


			常见面试题：==和equals的区别
			答案1：==如果作用于基本数据类型。就判断值是否相等。
			答案2：==如果作用于引用数据类型，就判断地址是否相等
			String str1 =  new String("你好")  ;
			String str2 =  new String("你好")  ;
			System.out.println( str1  ==  str2);//false
			System.out.println( 1  ==  1);//true
        
            String str1 = "你好";
			String str2 = "你好";
			System.out.println( str1  ==  str2);true
			意味着str1和str2的地址是一样的。
			总结：String声明变量的区别：
			String str = new String("xx");
			不管xx是什么，都要重新开辟一个新的内存。
			String str = xx ;
			如果xx存在了就不去开辟了 而是直接引用已经存在的，
            
            答案3：equals:只能作用于引用数据类型，本质就是==
			答案3：但是大部分的类都重写了equasl方法，例如String  ，Date
			答案3：重写之后的equals则是判断值是否相等 
			 
			String str1 = "你好";
			String str2 = "你好";
			System.out.println( str1.equals(str2) );//true 
            错误的解释：
            因为str1和str2都是直接声明的所有地址相等
			
			String str1 =  new String("你好") ;
			String str2 = "你好";
			System.out.println( str1.equals(str2) );//true 
            原因：
            String 也重写了equals方法,是判断值是否相等
			而非地址
		

            Student s = new Student(1, "张三", 18);
		
		
		    System.out.println(s.toString());
		    System.out.println(s);

易错点：

String不是八大基本数据类型
       但是String是Java中最常见的数据类型。可以存储字符串类型。
       数据中包含数字，字母，符号等都可以使用String声明
       声明方式如下：
       1.String str = “你好呀”;//直接声明，最常见

       2.String str = new String(“你好呀”);//通过构造方法new实例化声明，了解即可

       注意：null和空字符串的区别
        String str = null; //没有任何属性和方法的
        String str = "null";//正常的字符串
        String str = ""; //正常的字符串只是长度为0罢了

JavaScript的String既有属性也有方法

Java中的String没有属性只有方法。备注：JavaScript的String既有属性也有方法。
		常见方法如下：
		int length();返回字符串的长度。
		char charAt(int index);返回字符串中第几个字符，从0开始，注意下标溢出
		int indexOf(String str);返回str首次出现的位置,如果没有出现就为-1
		String substring(int index);从指定位置截取剩下的字符串
		String substring(int index,int end);从index开始到end结束截取字符串，
        包含index不包含end
		String toUpperCase();转大写
		String toLowerCase();转大写
		String trim()去除首尾的空格
		boolean endsWith(String str);是否以str结尾
		boolean startsWith(String str);是否以str开头
		boolean equals(String str);字符串的值是否相等
		String replace(String oldStr,String newStr);将旧字符串替换成新字符串
		String[] split(String str);将字符串以str的形式切割成数组
	*/

public static void main(String[] args) {
		//注意事项：String的方法都需要返回值接受
		
		
//		String str = "abc123";
//		System.out.println(str.length());//返回字符串的长度6
//		char a = str.charAt(1);
//		System.out.println(a);//b
//		System.out.println(str.indexOf("aaa"));//-1
//		System.out.println(str.indexOf("123"));//3
//		System.out.println(str.indexOf("12"));//3
//		System.out.println(str.indexOf("c"));//2
//		System.out.println("~~~~~~~~~~~~~~~~~~~~");
//		System.out.println(str.substring(2));//c123    包括2 包括制定的位置
//		System.out.println(str.substring(2,4));//c1    包括2,不包括4  
        技巧：凡是JAVA或JS 都有一句：左包含，右不包含
//		System.out.println(str.toLowerCase());//abc123
//		System.out.println(str.toUpperCase() );//ABC123
//		String str = "  11  22  ";
//		//注意事项：String的方法都需要返回值接受
//		str.trim();
//		System.out.println(str);//这里依然是原有的str 并没有去除空格
		
		
//		String str = "www.4399.com";
//		System.out.println( str.startsWith("www."));//T
//		System.out.println( str.endsWith(".com")   ||  str.endsWith(".cn")    );//T
		
//		System.out.println(str.replace("w","你"));
//		//replcae既可以实现替换 也可以实现删除
//		System.out.println(str.replace("9",""));
		
		
		String str = "1-2-3-4-5-6-7-8";
		String[] split = str.split("-");
		for(int i = 0 ;i<split.length;i++) {
			System.out.println(split[i]);
		}

String的补充：
			String被final修饰，意为最终类，无法被继承，也无法被修改。
			我们声明的字符串其实本质上都是被final修饰的常量。
			那么为什么可以随意修改呢？
			本质上并不是修改，而是直接丢弃原本的字符串，去声明一个新的字符串。
			所以如果某个字符串需要经常被修改，那么不推荐通过String声明，
            因为会产生大量的垃圾。（但是JVM自动回收，所以也可以用，但是不推荐。）
			而是通过StringBuffer声明。所以String几乎没有提供修改的相关方法，
            都是通过重新声明实现。
		
		*/
		
		String str = "111";
		System.out.println(str);
		str = "222";
		System.out.println(str);

练习：分别打印该字符串中，数字，小写字母，大写字母和符号的个数。

public static void main(String[] args) {
//		分别打印该字符串中，数字，小写字母，大写字母和符号的个数。
		String str = "22aaaAAAA```~~";
		int a = 0;
		int b = 0;
		int c = 0;
		int d = 0;
		
		for(int i = 0 ; i <str.length();i++) {
//			System.out.println(str.charAt(i));
			if( str.charAt(i) >='0'  &&  str.charAt(i)<='9'  ) {
				a++;
			}else if(str.charAt(i) >='a'  &&  str.charAt(i)<='z') {
				b++;
			}else if(str.charAt(i) >='A'  &&  str.charAt(i)<='Z') {
				c++;
			}else {
				d++;
			}
		}
		
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);

声明一个方法，该方法可以传入一个字符串。判断该字符串是否符合格式，并提示错误信息。要求如下：
       1.长度是否在10-16位。
       2.是否以yyzy开头
       3.是否以2023结尾
       4.是否包含“china”字符串
       5.是否为复杂密码（大写字母，小写字母，数字，字符。包含三类或以上）

public static boolean  a1(String str) {
		if(!(str.length()>=10 && str.length()<=16)) {
			System.out.println("长度有误");
			return false;
		}
		
		if(! str.startsWith("yyzy")) {
			System.out.println("不是以yyzy开头");
			return false;
		}
		
		if(! str.endsWith("2023")) {
			System.out.println("不是以2023结尾");
			return false;
		}
		
		if(str.indexOf("china") == -1 ) {
			System.out.println("没有包含china");
			return false;
		}
		//分别表示是否含有相对于的密码
		boolean a1 = false;
		boolean a2 = false;
		boolean a3 = false;
		boolean a4 = false;
		int index = 0;
		
		for(int i = 0 ; i <str.length();i++) {
			if( str.charAt(i) >='0'  &&  str.charAt(i)<='9'  ) {
				a1 = true;
			}else if(str.charAt(i) >='a'  &&  str.charAt(i)<='z') {
				a2 = true;
			}else if(str.charAt(i) >='A'  &&  str.charAt(i)<='Z') {
				a3 = true;
			}else {
				a4 = true;
			}
		}
		
		if(a1) {
			index++;
		}
		if(a2) {
			index++;
		}
		if(a3) {
			index++;
		}
		if(a4) {
			index++;
		}
		//判断a1 a2 a3 a4 四个变量中 只要有3个或4个 true即可成功
		if(index<3) {
			System.out.println("密码不够复杂");
			return false;
		}
		
		
		
		System.out.println("密码格式正确");
		return true;
	}
	
	
	public static void main(String[] args) {
		String str = "yyzy1china--2023";
		boolean a1 = a1(str);
		System.out.println(a1);
	}

 声明一个方法，该方法可以传入一个字符串。判断该字符串是否符合格式，并提示错误信息。要求如下：
		1.长度是否在10-16位。
		2.是否以yyzy开头
		3.是否以2023结尾
		4.是否包含“china”字符串
		5.是否为复杂密码（大写字母，小写字母，数字，字符。包含三类或以上）

        public static boolean a1(String str){  //判断为布尔型的返回值
		if(!(str.length()>10 && str.length()<=16)) {
			System.out.println("长度有误");
		    return false;
		}
	    if(!str.startsWith("yyzy")){
		  System.out.println("不是以yyzy开头");
		  return false;
	    }
	
	    if(str.indexOf("china") == -1) {  //返回str首次出现的位置,如果没有出现就为-1)
	    	System.out.println("不包含china");
	    	return false;
	    }
		return false;
	    }
		 static void main(String[] args) {
		String str ="yyzy1china-2023";
		boolean a1=a1(str);
		System.out.println(a1);
	}

StringBuffer

如果某个字符串需要经常被更改例如密码，那么推荐使用StringBuffer来声明。
           语法如下：
           StringBuffer str = new StringBuffer( String str );
           备注：不能像String那样直接声明。
           StringBuffer的特点：对字符串的增删改查都是在原有的基础上进行修改，
           而非像String一样。

StringBuffer str= new StringBuffer("aaa");
//           StringBuffer常见的方法(和String的方法大同小异，列举出几个不同的)
//           append(Object o); 往尾部添加任意类型的值。
//           注意：这里不像String一样，一定需要返回值接受。
//           insert(int I,Object o);在指定位置插入指定类型数据
           str.append("你好");

           str.append(true);
           str.append(123);
           System.out.println(str);
           str.insert(2, "bbb");
           System.out.println(str);

String str = "1234";
str.replace("1","aa");
System.out.println(str);无法修改成功，因为上面没有加返回值

通过String分别演示字符串的增删改查。

例如字符串为：“123abc”
           要求：
           将1修改成你
           将2删除
           在ab的中间添加~
           将修改后的字符串输出在控制台上，

	String str = "123abc";
//		str = str.replace("1", "你");
//		str = str.replace("2", "");
//		str = str.replace("ab", "a~b");
//		System.out.println(str);

测试String和StringBuffer的执行效率。

//通过for循环，在字符串尾部添加若干次字符串实现。
		
		
		//思路1：如何计算某一段代码的执行时间
		//解答:在代码的前后分别声明开始的时间和结束的时间
		//System.currentTimeMillis()返回值是一个long  表示 计时功能  
        表示当前的时间为系统时间 单位是毫秒
		
		
		
//		String str = "";
//		//定义开始时间
//		long l1 = System.currentTimeMillis();
//		for(int i = 1 ; i<=10000;i++) {
//			str = str + i;
//		}
//		//定义结束时间
//		long l2 = System.currentTimeMillis();
//		System.out.println(l2-l1);//150
		
		
		StringBuffer str =new StringBuffer("");
		
		
		//定义开始时间
		long l1 = System.currentTimeMillis();
		for(int i = 1 ; i<=10000;i++) {
			str.append(i);
		}
		//定义结束时间
		long l2 = System.currentTimeMillis();
		System.out.println(l2-l1);//150
		
		
		
		//结论：StringBuffer如果修改字符串 比String效率高的多。
		//衍生：Java的世界里面。一行代码的区别，带来的效率是上百倍甚至上千倍。
		
		
		
	}

获取日期

注意：Date 日期和 Data 数据数据库：Database
           Java中针对时间日期类型提供了Date工具类。
           使用之前需要进行导包，和Scanner类非常类似: java.util.Date
           注意是util下的Date！

           导包：大部分的常用包都没有导入，原因：Java自带的一个包叫做 Java.lang.*包该包下得类都是自动导入
           例如String System

           需要的手动导入：Scanner

常见的获取Date对象方式如下：
Date d = new Date();//获取当前时间
常见的过时方法：···

Date d = new Date();//下面的方法是过时的，但是这个对象不过时
		System.out.println(d);//发现：结果是对中国人不友好的
		//所以需要通过大量的过时方法来对中国人民友好
		//过时方法：仅仅是针对  大量的用户   翻译：如果你的项目很多很多人使用，
        就不推荐使用下面的方法
		//如果用户数量较少，可以使用，但是不推荐。
//		int year = d.getYear();
//		System.out.println(year+1900);
//		int month = d.getMonth();
//		System.out.println(month + 1);
//		int date = d.getDate();
//		System.out.println(date);
//		int h = d.getHours();
//		int m = d.getMinutes();
//		int s = d.getSeconds();
//		System.out.println(h+":" + m + ":" + s);

Date对象的方法

由于Date对象的99%的方法都已经过时
			备注：Date d = new Date();还是没有过时，依然是获取当前时间的唯一方法。
			
			所以Java提供了SimpleDateFormat类，来替代Date的绝大部分方法，来对时间进行操作。
			Simple:简单的
			Date：日期
			Format：格式
			
			
			语法如下：
			SimpleDateFormat sdf = new SimpleDateFormat(“日期的具体格式”);
			日期具体格式如下：
			yyyy-MM-dd HH:mm:ss
			yyyy/MM/dd HH:mm:ss
			yyyy-MM-dd
			HH:mm:ss
			格式可以随便改，但是字母不能。yyyy表示年  MM表示月  dd日期   HH小时 mm分钟 ss秒
			
			注意：yyyy和MM 和dd和mm和ss  是固定的
			但是HH表示24小时制的时间
			hh表示12小时的时间
			
			其中字母定死了，符号可以根据场景改变。
			字母可以省略，例如只保留年月日或只保留时分秒。

如何获取当前时间

//如何获取当前时间
//		//1.定义时间的格式
//		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
//		//2.获取当前时间
//		Date d = new Date();
//		//3.格式化时间
//		String str = sdf.format(d);
//		System.out.println(str);
		
		
		
		
		//某些场景：可能需要过去或未来的时间 方法如下：
		String str = "2030/8/8   12:12:12";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
		Date date = sdf.parse(str);
		System.out.println(date);

Math类

Java提供了Math类来执行基本的数学运算。
该类处于java.lang下，所以使用无需导包。
该类下的所有方法都是静态方法，故无需new对象。

public static void main(String[] args) {
		
//		doule Math.floor(double x);  向下取整，但是依然是double类型。
		System.out.println(Math.floor(1.1));//1.0
		System.out.println(Math.floor(1.0));//1.0
		
		
//		double Math.ceil(double x);向上取整，但是依然是double类型
		System.out.println(Math.ceil(1.1));//2.0
		System.out.println(Math.ceil(1.0));//1.0
		
//		long Math.round();四舍五入
		System.out.println(Math.round(1.1));//1
		System.out.println(Math.round(1.5));//2
		System.out.println(Math.round(1.9));//2
		
		//总结：四舍五入如果碰到± xxx.5 优先往大的数走
		System.out.println(Math.round(-1.1));//-1
		System.out.println(Math.round(-1.5));//-1
		System.out.println(Math.round(-1.9));//-2
		
//		double Math.random();取一个大于等于0但是小于1的小数  
        官方概念是这样，但是实际上可以不用考虑0
		System.out.println(Math.random());

学会看API（教学文档，可以了解一些方法的组成以及如何使用）：语法如下：
数据类型方法名(参数列表);
数据类型：方法的返回值

练习：利用生成10000次 1-10的随机数，分别统计次数
然后打印在控制台上。

	Math.random()*10+1;//  [0,1)*10 = [1,11) --向下取整 [1, 10]
//		System.out.println( (int) Math.floor(  Math.random()*10+1));
		
		//分别统计1-10的次数
		int a = 0;
		int b = 0;
		int c = 0;
		int d = 0;
		int e = 0;
		int f = 0;
		int g = 0;
		int h = 0;
		int i1 = 0;
		int j = 0;
		for(int i = 1;i<=100000;i++) {
			int r = (int) Math.floor(  Math.random()*10+1);
			
			switch (r) {
			case 1:
				a++;
				break;
			case 2:
				b++;
				break;
			case 3:
				c++;
				break;
			case 4:
				d++;
				break;
			case 5:
				e++;
				break;
			case 6:
				f++;
				break;
			case 7:
				g++;
				break;
			case 8:
				h++;
				break;
			case 9:
				i1++;
				break;
			case 10:
				j++;
				break;
			}
		}
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println(f);
		System.out.println(i1);
		System.out.println(g);
		System.out.println(h);
		System.out.println(j);

public static void main(String[] args) {
		int arr[] = new int[11];
		//arr[1] = 0;arr[2] = 0;arr[3] = 0;
		
		
        for(int i = 1;i<=100000;i++) {
            int r = (int) Math.floor(  Math.random()*10+1);
            arr[r] = arr[r] + 1;
        }
        for (int i = 1; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

包装类

包装类是专门针对于基本数据类型而言。
由于基本数据类型没有方法或属性。
为了更加方便对基本数据类型的值进行操作，Java提供了八大基本数据类型的包装类。

boolean byte
char short
int float
double long

Boolean Byte
Character Short
Integer Float
Double Long

包装类如何声明变量

//包装类如何声明变量 和String一样
		Integer a = 123;//直接声明
		Integer b = new Integer(123);//通过构造方法声明
		
		//包装类的用途：
		//1.作为实体类属性的数据类型，替换基本数据类型。
		//以前的写法 见下方的Student类
		Student s = new Student(123, "张三", 18,18);
		Student s1 = new Student();
		System.out.println(s);
		System.out.println(s1);
		
		//缺点：基本数据类型的默认值为0   而引用数据类型的默认值为null
		
		//2.将字符串转为对应的基本数据类型
		String str = "123445";
		int i = Integer.parseInt(str);
		System.out.println(i);	
		double d = Double.parseDouble(str);

class Student {
	private int id;
	private String name;
	private int age;
	private Integer age123;
	public Student(int id, String name, int age,Integer age123) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public Student() {
		super();
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", age123=" + age123 + "]";
	}

包装类的补充：


		包装类的补充：
		仅做了解为了面试 实际开发用不到
	*/

	public static void main(String[] args) {
		//自动装箱值得是：将基本数据类型 变成  包装类
//		int a = 11;
//		Integer b = a;//此过程就是自动装箱
//		
//		//自动拆箱值得是：将包装类转成基本数据类型
//		Integer c = 1;
//		int d = c.intValue();
//		
		
		//常见面试题：
		
//		String str1 = "你好";
//		String str2 = "你好";
//		String str3 =  new String("你好");
//		System.out.println(str1==str2);//true
//		System.out.println(str1==str3);//f
//		
//		System.out.println(str1.equals(str2));//t
//		System.out.println(str1.equals(str3));//t
//		
//		System.out.println(str2==str3);//f
//		System.out.println(str2.equals(str3));//t
		
		//Integer和String的类似度高达99%
//		Integer str1 = 1;
//		Integer str2 = 1;
//		Integer str3 = new Integer(1);
//		System.out.println(str1==str2);//true
//		System.out.println(str1==str3);//f
//		
//		System.out.println(str1.equals(str2));//t
//		System.out.println(str1.equals(str3));//t
//		
//		System.out.println(str2==str3);//f
//		System.out.println(str2.equals(str3));//t
		
		Integer str1 = 1111;
		Integer str2 = 1111;
		Integer str3 = new Integer(1111);
		System.out.println(str1==str2);//false
		System.out.println(str1==str3);//f
		
		System.out.println(str1.equals(str2));//t
		System.out.println(str1.equals(str3));//t
		
		System.out.println(str2==str3);//f
		System.out.println(str2.equals(str3));//t

Integer直接声明变量和String非常类似 ，都有一个类似缓存池的存在
String直接声明：先去缓存池找是否存在，如果不存在就new一个，如果存在就直接引用
Integer直接声明：现在-128~127的缓存池找是否存在，如果不存在就new一个，如果存在就直接引用

软件2201谢佩霖

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java面向对象（第三章异常和Object类）

异常的相关概念：（笔记chap9）Java在运行过程中或编译过程中，难免会出现一些报错，导致程序运行的中断，这些报错其实指的就是异常。所以我们需要如何解决这些错误，也就是如何解决异常。更需要看到报错信息，能够快速找到异常出现的位置，然后将它修改。
复制链接

扫一扫