＜3＞第三期到java异常

沁颖呀

已于 2022-06-20 16:38:45 修改

阅读量78

点赞数 1

文章标签： java 开发语言

于 2022-06-19 13:04:46 首次发布

本文链接：https://blog.csdn.net/weixin_49141056/article/details/125356862

版权

2.14Object类：Object类是所有类的父类，可使用官网api查询工具查询具体需要

1，public String toString() 返回该对象的字符串表示。

2，public boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”

package com.java1234.pro_27;

public class People {
	private String name;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	//生成构造方法，使用字段， 
	public People(String name) {
		super();
		this.name = name;
	}

	@Override
	//若需要在打印对象的时候直接打印出名字，可以子类重写父类的toString方法
	public String toString() {
		return this.getName();
	}
	@Override
	//们需求，在name相同时候，就相等，重写子类的equals方法

 - List item

	public boolean equals(Object obj) {
		String name=((People)obj).getName();
		return this.name==name;
	}
	public static void main(String[] args) {
		People p1=new People("张三");
		People p2=new People("张三");
		People p3=new People("李四");
		// equals 是比较对象的引用，是否指向同一个堆内存；
		System.out.println("p1和p2:"+p1.equals(p2));
		System.out.println("p1和p3:"+p1.equals(p3));
		System.out.println("p2和p3:"+p2.equals(p3));
		
        //默认调用的是toString()方法；
		System.out.println(p1);  //本质与调用toString一样的，都是指向堆内存地址
		System.out.println(p1.toString());
	}
}

2.15、instanceof关键字：断一个对象是否属于一个类

public class Test {
	// static静态方法直接调用外部方法，需要加上static，否则需要通过对象来实现。
	//传入一个父类引用
	//判断一个对象是否属于一个类
	public static void dosomeThing(Animal animal){
		animal.say();
		if(animal instanceof Dog){
			((Dog) animal).f2();
		}else if(animal instanceof Cat){
			((Cat) animal).f1();
		}
	}
	public static void main(String[] args) {
		Animal dog=new Dog();
		System.out.println("dog类是否属于Animal类:"+(dog instanceof Animal));
        
		// 进行向下转型，会报错，在dosomeThing里面写好逻辑，防止转型错误
		dosomeThing(new Dog());
		dosomeThing(new Cat());
	}

}

2.16匿名内部类：实例化内部对象就是没有名字的内部类

1.作用：假如某个类只使用一次，则可以使用匿名内部类；

// 定义一个接口
public interface A {

    public void a();
}
// 一个实现类

public class B implements A{
 
    @Override
    public void a() {
        System.out.println("a方法");
    }
 
}
// 具体测试类
public class Test {
    
  public void test(A a){
        a.a();
    }  
    public static void main(String[] args) {
        Test t=new Test();
        t.test(new B());
    }
}
/*在开发时候，看看接口是否有实现的类，若没有则采用匿名内部类开发，使用匿名内部类的时候，
要在匿名内部类汇总添加实现方法
*/

public interface C {
	public void name();
}

public class test {
	//多态
	public  void test(A a){
		a.a();
	}
	public void test(C name){
		name.name();
	}
	
	public static void main(String[] args) {
		test t=new test();
		t.test(new B());
	//此时若需要实现C接口，但是他没有具体的实现，则就可以使用匿名内部类，特性，一次使用
		t.test(new C(){

			@Override
			public void name() {
				System.out.println("我是C的匿名内部类");
			}
		});
	}
}

2.17包装类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6KsbF4Xm-1655614870633)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220619005531915.png)]

List item

1，装箱和拆箱

基本类型和类类型可以相互转换；

基本类型到类类型的转换叫做装箱；

类类型到基本类型的转换叫做拆箱；

public class Demo1 {

    public static void main(String[] args) {
          //int的缓存范围值是-128到127
		   // a=时候 会把int转为包装类(Integer)，此时底层会new Integer(),重新分配内存地址
        int a=1; //正常的定义变量
        Integer i=new Integer(a); // 装箱  放进去 
        int b=i.intValue(); // 拆箱 取出来
        System.out.println("a="+a);
        System.out.println("i="+i);
        System.out.println("b="+b);
    }
}
// 运行的结果都是1

2，自动装箱和拆箱

在类类型和基本类型的转换中，是自动转换的无需强制类型转换；

public class Demo2 {
 
    public static void main(String[] args) {
        Integer i=1; // 自动装箱的过程 自动把基本类型转换成类类型
        int i2=i; // 自动拆箱的过程 自动把类类型转成基本类型
        System.out.println("i="+i);
        System.out.println("i2="+i2);
    }
}

3，包装类的作用

比如从用户界面来两个字符串数据a,b 然后我们程序里要进行相加运算。这时候包装类就派上用场了，

我们可以用包装类的方法类进行类型转换。我们看下示例代码：

public class Demo3 {
 
    public static void main(String[] args) {
        String a="3";
        String b="5";
        // 此时若直接相加两个字符串，行不通，可以采取转包装换
        int m=Integer.valueOf(a); // 调用Integer类的valuesOf方法 把字符串类型转换成int类型
        int n=Integer.valueOf(b);
        System.out.println("a+b="+(m+n));
    }
}

2.18Java设计模式-单例模式

计模式有很多有单例，工厂，代理等等

单例对象能保证在一个JVM中，该对象只有一个实例存在；有两种实现，一种是饿汉式，一种是懒汉式；

1.饿汉式：

package com.java1234.chap03.sec18;
 
public class Singleton {
 
    /**
     * 构造方法私有
     */
    private Singleton(){
         
    }
     
    /**
     * 饿汉式单例实现
     */
    private static final Singleton single=new Singleton();
     
    /**
     * 获取实例
     */
    public static Singleton getInstance(){
        return single;
    }
}
/*
这里我们构造方法私有 这样就保证了在外部是无法来实例化对象；
然后我们先在内部定义一个静态常量对象，然后再写一个static方法 来返回这个对象，这样就保证是一个对象了；*/
// 测试类
package com.java1234.chap03.sec18;
 
public class Test {
 
    public static void main(String[] args) {
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println(singleton1==singleton2);
    }
}

//这里获取里两个对象 我们前面讲过 用“==”来判断对象是否指向同一个内存区域，这里返回true，说明是同一个对象；

2.懒汉式；

package com.java1234.chap03.sec18;
 
public class Singleton2 {
 
    /**
     * 构造方法私有
     */
    private Singleton2(){
         
    }
     
    /**
     * 懒汉式单例实现 在第一次调用的时候实例化
     */
    private static Singleton2 single;
     
    /**
     * 获取实例
     */
    public synchronized static Singleton2 getInstance(){
        if(single==null){
            System.out.println("第一次调用的实例化");
            single=new Singleton2();
        }
        return single;
    }
}
/*
我们可以看到 区别  饿汉式是先定义实例的 而懒汉式是先定义引用，当第一次调用getInstance的时候 进行对象实例化操作；
当然这里我们考虑到多并发的情况 多个线程同时调用这个方法的时候，会出现问题，所以我们加了同步锁 synchronized 来保证
同一时刻只有一个线程进入方法；*/

// 测试类
package com.java1234.chap03.sec18;
 
public class Test {
 
    public static void main(String[] args) {
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println("饿汉式："+(singleton1==singleton2));
         
        Singleton2 singleton3=Singleton2.getInstance();
        Singleton2 singleton4=Singleton2.getInstance();
        System.out.println("懒汉式："+(singleton3==singleton4));
         
    }
}

四、Java异常处理

1.异常概念

package com.java1234_4;

public class Demo1 {
	// 异常的概念 程序在执行过程中，出现意外，我们专业属于叫做出现了异常；类似开车路上出了交通事故；
	//正常程序
    public static void main(String[] args) {
		String a="123";
		int b=Integer.parseInt(a);
		System.out.println(a);
		
		
		
		 //不正常程序  ,这就是异常，在处理数值时候，编译报错
	    String c="12a";
	    int d=Integer.parseInt(c);
		System.out.println(c);
	}

2.Java异常处理-捕获和处理异常

在java中，我们用try-catch来捕获异常

public class Demo2 {
	public static void main(String[] args) {
		String a="1231e";
		try{
			int b =Integer.parseInt(a);
		}catch(Exception e){
		e.printStackTrace();
		}
		System.out.println("end");
	}
}

假如我们不确定会抛出什么异常，我们可以写多个异常捕获：

注意由上往下的异常必须范围同级别或者更高详情科查api文档，Exception是异常的祖先

public class Demo1 {
 
    public static void main(String[] args) {
        String str="123a";
        try{
            int a=Integer.parseInt(str);          
        }catch(NullPointerException e){
            e.printStackTrace();
        }catch(NumberFormatException e){
            e.printStackTrace();
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("继续执行");
    }
}

try…cacth…finally 在finally里面的代码都会执行，在这个环境中，try…catch中的代码不一定会执行

但是在finally中的代码一定会执行

package com.java1234_4;

public class Demo2 {
	public static void main(String[] args) {
		String a="eee";
		try{
			int b =Integer.parseInt(a);
		}catch(NumberFormatException e){
		e.printStackTrace();
		} catch(InternalError e){
			e.printStackTrace();
		}catch(NullPointerException e){
			e.printStackTrace();
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			System.out.println("无论什么异常，都会执行");
		}
		System.out.println("end");
		
	}

}

3.Java异常处理-throws和throw关键字

throws表示当前方法不处理异常，而是交给方法的调用出去处理；

throw表示直接抛出一个异常；不处理

//throws表示当前方法不处理异常，而是交给方法的调用出去处理；
public class Demo3 {
	//这是一个方法，在方法上抛出异常,在调用的地方去解决异常
	public static void  testThrows() throws NumberFormatException{
		String a="asd123";
		int b=Integer.parseInt(a);
		System.out.println(a);
	}
	public static void main(String[] args) {
	// 	此处调用放方法，则说明该处需要去解决异常  try  catch解决
		try{
			testThrows();
			System.out.println("here");
		}catch(Exception e){
			e.printStackTrace();
			System.out.println("我们在这处理异常");
		}
		System.out.println("I 'm here");
	}

}

//throw表示直接抛出一个异常；不处理 
public class Demo2 {
 
    public static void testThrow(int a) throws Exception{
        if(a==1){
            // 直接抛出一个异常类
            throw new Exception("有异常");
        }
        System.out.println(a);
    }
    public static void main(String[] args) {
        try {
            testThrow(1);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

4.Java异常处理-Exception 和 RuntimeException 区别

Exception是检查型异常，在程序中必须使用try…catch进行处理；

RuntimeException是非检查型异常，例如NumberFormatException，可以不使用try…catch进行处理，

但是如果产生异常，则异常将由JVM进行处理；

RuntimeException最好也用try…catch捕获；

public class Demo1 {
 
    /**
     * 运行时异常，编译时不检查，可以不使用try...catch捕获
     * @throws RuntimeException
     */
    public static void testRuntimeException()throws RuntimeException{
        throw new RuntimeException("运行时异常");
    }
     
    /**
     * Exception异常，编译时会检查，必须使用try...catch捕获
     * @throws Exception
     */
    public static void testException()throws Exception{
        throw new Exception("Exception异常");
    }
     
    public static void main(String[] args) {// 
       //  testException();   // testException()报错，我们对testException()加下try...catch即可；
         try {
            testException();
        } catch (Exception e) {
            e.printStackTrace();
        }
        testRuntimeException();
    }
}