首页 博客列表 精选博客 每日焦点 关于我
day15学习笔记
发布日期：2021-05-18 05:20:16 浏览次数：33 分类：原创文章

本文共 9758 字，大约阅读时间需要 32 分钟。

知识点一：异常
/**
* 异常 : 程序在运行时出现的非正常状况 . 异常会导致程序崩溃
异常的分类 :
* 1) 按照程度来分
* 1) Error 严重错误 .
* 2) Exception 一般问题 .
 
* 2) 按照处理方式来分
* 1) 受检异常 (checked) 在程序中 必须 接受检查和处理的异常 . 如果不处理编译错误 , 也称为 编译时异常
* Exception 及其子类 (RuntimeException 及其子类除外 )
* 2) 非受检异常 (unchecked) 在程序中 不是必须 接受检查和处理的异常 , 如果不处理不生编译错误 , 但是运行时仍会出问题 , 也称为 运行时异常
     Error 及其子类------非受检异常
     RuntimeException 及其子类-------非受检异常 .
 
异常必须处理 : 适用于所有异常 , 包括 Error
1) 捕获-------try catch结构
* try {
* 可能抛出异常的语句 ;
* } catch ( 可能的异常类型 1 引用 ) {
* 对异常处理 .
* } catch ( 可能的异常类型 2 引用 ) {
* 对异常处理 .
* } .....
* catch (Exception e) {
* 确保万无一失
* } finally { // final 修饰符 , 修饰类 , 方法 , 变量
        无论前面try,catch发生什么都要执行。
        通常在这里释放资源的操作。不在 GC 区中资源 , 而是由 OS 管理的资源 . 比如文件 , 网络等硬件资源 .
* }
组合（三种）：
* try catch
* try catch finally
* try finally
 
2) 抛出 : 使用 throws 体现异常的抛出 .----核心是throws，最好要配合使用throw，表示诚实。
 
在方法签名中使用 throws 异常类型列表 , 作用是警告调用者 , 此方法有风险 .
在方法体中使用 throw 语句 , 在方法中真的抛出异常对象 .
 
* 可以只有 throws 而没有 throw
* 只要有 throw 必须要有 throws
*
* throws 是警告，往上抛。不是真正的处理。
* throw 是玩真的 . 只有这个方法，才是真正的处理。
 
* 3) 先捕获 , 再抛出 . ----本质上抛出了两个异常
* 先
* try {
* 可能抛出异常的语句 ;
* } catch(某个 任意异常类型 引用 ) {
* throw new 自定义异常 ( 引用 );-----已知异常对象作为实参。对象关联。
* }
 
处理方式的选择 : （如果出现了异常，是破坏了谁）
* 1) 入口方法尽量 捕获 . （栈底的方法出现问题是会影响大局的，栈一旦空，这个程序就 over 了。所以影响栈生死存亡的方法不能抛，要及时处理）
* 2) 功能方法尽量 抛出 .--->抛出异常实质上是一个消息反馈机制。 （把出错问题暴露出来，让调用者及时知晓，避免整体程序最后程序出错）
 
方法覆盖条件中对于异常的描述 :  一旦是非受检异常，就不受任何约束，他都不用检查的
* 要求如下 :
* 1) 方法签名一致 , 子类方法的返回值的对象类型 可以小于等于 父类方法返回的对象类型 .
* 2) 子类方法的访问控制修饰符的范围要 大于等于 父类的 .
* 3) 被覆盖方法不可以被 private, static(隶属于类), final.
* 4) 子类方法抛出的 受检异常范围要小于等于 父类方法抛出的受检异常 .--> 其实就是多态的时候，调方法是以父类为准，父类抛的异常小写，但是实际抛的确实子类的大的异常。那么 catch 就处理不了。
*/
 
// 自定义异常类 : 1) 继承Exception 表明它是一个异常, 2) 提供2个构造器一个String,一个是Throwable。 目的：创建自定义异常对象方便
 
 
class DividedByZeroException extends Exception { // 这是受检异常, 必须要处理
//构造器
    public DividedByZeroException(String message) {
        super(message); // 间接调用到父类构造, 完成私有的detailMessage的初始化.
    }
    //一个异常内部拥有另外一个异常对象
    public DividedByZeroException(Throwable cause) { // 对象关联专用，这个对象拥有另外一个对象作为属性，例如，我把电脑作为我的一个属性。 创建自定义类异常对象，传入了另外一个异常对象。
        super(cause);
    }
}
 
 
public class ExceptionTest {
    // 包装 : 自定义异常对象内部包含一个其他异常对象.
    public static int divide(int x, int y) throws DividedByZeroException {  //通过throws警告一下，警告谁呢？警告调用者
        try {
            return x / y;
        } catch (ArithmeticException e) {  //一下抓住这个ArithmeticException异常对象，然后包装到DividedByZeroException这个对象里面去。再把这个DividedByZeroException给扔出来。
            throw new DividedByZeroException(e); //以这个ArithmeticException已知异常对象为参数
        }
    }
 
 
    public static void main(String[] args) {
        try {
            try {
                System.out.println(divide(10, 2));
                System.out.println(divide(10, 0));
            } catch (DividedByZeroException e) {
                System.out.println(e.getMessage());
            }
            System.out.println(divide(20, 5));  //这里就是调用者，调用20 和5
        } catch (DividedByZeroException e) {
            e.printStackTrace();
        } finally {
            System.out.println("finally");
        }
    }
}
 
 
class ExceptionTest3 {
    // 在方法处的throws的作用是警告调用者, 调用此方法有风险!!!
    public static int divide(int x, int y) throws DividedByZeroException { // throws和throw最好要一致, 显得诚实
        if (y == 0) {
            // 真的抛出一个异常对象, 当前方法就会提前弹栈返回结束, 并给调用者产生破坏.
            throw new DividedByZeroException("除数不可以为0错误!!!!"); //这里是调用构造器，传入message形参
        }
        return x / y;
    }
 
 
    //public static void main(String[] args) throws DividedByZeroException {  //main方法虽然可以抛出异常, 但是不要抛.抛出来，就被操作系统干掉了。整个程序就会强制关闭
    public static void main(String[] args) {
        try {
            System.out.println(divide(10, 2));
            System.out.println(divide(10, 0));
        } catch (DividedByZeroException e) {
            System.out.println(e.getMessage());
        }
 
 
        System.out.println("end");
    }
}
 
 
class ExceptionTest2 {
 
 
    public static int divide(int x, int y) {
        if (y == 0) {
            RuntimeException re = new RuntimeException("除数不可以为0"); // throw和return效果一样, 都是让方法返回的
            throw re;
            // return 是和平返回, throw 带有破坏性的返回.
        }
        return x / y;
    }
 
 
    public static void main(String[] args) {
        try {
            System.out.println(divide(10, 2));
            System.out.println(divide(10, 0));
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
        }
        System.out.println("end...");
    }
}
 
 
 
class ExceptionTest1 {
 
    public static void main(String[] args) {
        System.out.println("main begin");
 
 
        boolean b = true;
        if (b) {
            //return;
        }
 
 
        try {
            int n = Integer.parseInt(args[0]);
            System.out.println(n);
            return;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
        } catch (NumberFormatException e) {
            System.out.println(e.getMessage());
        } catch (Exception e) {
            System.out.println("其他可能的异常 : " + e);
        } finally {
            // 无论前面try catch中发生什么, 我都要执行....
            System.out.println("finally");
        }
 
 
        System.out.println("main end");
    }
}
 
 
 
知识点二：接口的代理模式
/**
接口的特点：让完全不同类型的对象统一起来 。接口就是对不同类型的对象的统一。
*
* 代理 : 把代理对象当成被代理对象来使用 .---> 也就是有两个对象，一个是代理，一个是被代理。自己（被代理对象） -- 律师（就是代理） --- 法官把律师当成我。
* 代理和被代理对象之间有一个桥梁，这个桥梁，就是接口。 ---> 接口的一个典型应用。
* 接口就是代表一个能力。
* 
* 代理模式的场景 :
* 1 使用者无法直接创建被代理对象。通过代理对象来完成。例如：来上海租房子，自己不知道怎么做，就找房屋中介来帮助自己。因为中介有找房子的能力。
* 2 （最主要场景）对于被代理对象的方法有改进的需求 . 但是同时不能修改被代理类。无形中，通过代理类，把被代理类功能增强了。比如，我想用支付宝转账，房东只收现金，这怎么办，通过中介。
*
* @author zhouyanjun
* @create 2020-07-13 23:23
*/
//这是一个接口，表示有租到房子这个能力
interface HouseRent {
    void rent();
}
 
 
//房东具备这种能力
class FangDong implements HouseRent {
 
 
    @Override
    public void rent() {
        System.out.println("我有房子要出租");
    }
}
 
 
//链接也要实现接口，因为他也必须要具有租房的能力
class LianJia implements HouseRent {
    //内部关联了对象。这个对象拥有另外一个对象作为属性。
    private HouseRent fd = new FangDong(); //这个声明也可以是接口，能提供租房功能的对象。
 
 
    @Override
    public void rent() {
        //是链家在出租房子
        System.out.println("请交中介费5000，不然不给出租");
        fd.rent();//原始方法调用。这里是切面，体现AOP
        System.out.println("要及时交房租，不然你住不了。支持微信，支付宝");
    }
}
 
 
public class ProxyTest {
    public static void main(String[] args) {
        //我们就是main方法。用户只身一人在上海，不会租房。
        //用户只能new代理对象
        //接口的使用，降低了对对象的要求
        HouseRent zufang = new LianJia();//无论我new的是什么，我只在乎能否租到房
        zufang.rent();
    }
}
 
 
 
知识点三：String
/**
* @author zhouyanjun
* @create 2020-07-14 14:25
*/
 
import org.junit. Test ;
 
/**
* String : 内容不可改变的 Unicode 字符序列 , 对象一旦创建 , 内容不能改变 .
* 对于字符串的内容的任何修改都会产生新对象 .
* 字符串内部就是使用一个 char[] 来保存所有字符的 .
*
* Customer cu = new Cutomer();
* cu.setAge(20); // 内容可以改变的对象
* cu.setAge(50);
*
* 0 2 10 15 21 27 32 34
* String string = " abcAQQY 我喜欢你 , 你喜欢我吗 ? 我不喜欢你 zzz123 ";
*
* public int length(). string.length() => 35 获取字符串长度 ( 字符数 )
* public char charAt(int index) 获取指定下标位置处的字符 string.charAt(12) => ' 欢 ', string.charAt(18) => ' 我 ';
* public char[] toCharArray() 获取内部的 char[]
* char result[] = new char[value.length]; // 创建一个新数组 , 容量和内部的 value 一样大 .
*
* for (int i = 0; i < value.length; i++) {
* result[i] = value[i];
* }
*
* System.arraycopy(value, 0, result, 0, value.length);
* // 第一个参数是源数组对象 , 第二个参数是源数组的开始下标 , 第三个参数是目标数组对象 , 第四个参数是目标数组的开始下标
* // 第五个参数是要复制的元素个数 .
* public boolean equals(Object anObject)
* public int compareTo(String anotherString)
* public int indexOf(String s)
* public int indexOf(String s ,int startpoint)
* public int lastIndexOf(String s)
* public int lastIndexOf(String s ,int startpoint)
* public boolean startsWith(String prefix)
* public boolean endsWith(String suffix)
* public String substring(int start,int end)
* public String substring(int startpoint)
* public String replace(char oldChar,char newChar)
* public String replaceAll(String old,String new)
* public String trim()
* public String concat(String str)
* public String toUpperCase()
* public String toLowerCase()
* public String[] split(String regex)
*/
 
 
 
 
 
public class StringTest {
 
// 练习 : 把字符串反转一下
@Test
public void exer13 () {
String string = " abcAQQY 我喜欢你 , 你喜欢我吗 ? 我不喜欢你 zzz123 " ;
char [] arr = string. toCharArray ();
for ( int i = 0 ; i < arr. length / 2 ; i++) {
// 首尾交换 , i 和 length - 1 - i
char tmp = arr[i];
arr[i] = arr[arr. length - 1 - i];
arr[arr. length - 1 - i] = tmp;
}
String string2 = new String (arr);
System . out . println (string2);
}
 
@Test
public void exer12 () {
String string = " abcAQQY 我喜欢你 , 你喜欢我吗 ? 我不喜欢你 zzz123 " ;
String string2 = "" ;
for ( int i = 0 ; i < string. length (); i++) {
char ch = string. charAt (i);
string2 = ch + string2;
}
System . out . println (string2);
}
 
@Test
public void exer1 () {
String string = " abcAQQY 我喜欢你 , 你喜欢我吗 ? 我不喜欢你 zzz123 " ;
String string2 = "" ;
for ( int i = string. length () - 1 ; i >= 0 ; i--) {
char ch = string. charAt (i);
string2 += ch;
}
System . out . println (string2);
}
 
@Test
public void test5 () {
String string = " abcAQQY 我喜欢你 , 你喜欢我吗 ? 我不喜欢你 zzz123 " ;
System . out . println (string. length ());
System . out . println (string. charAt ( 13 ));
System . out . println (string. charAt ( 0 ));
System . out . println (string. charAt ( 32 ));
//System.out.println(string.charAt(500));
System . out . println ( "**************************" );
for ( int i = 0 ; i < string. length (); i++) {
char ch = string. charAt (i);
System . out . println (ch);
}
System . out . println ( "***************************" );
char [] chars = string. toCharArray ();
for ( int i = 0 ; i < chars. length ; i++) {
System . out . println (chars[i]);
}
}
 
@Test
public void test4 () {
char [] arr = { 'a' , '1' , 'q' , ' 我 ' , '3' , ' 好 ' , 'o' };
String s1 = new String (arr); // 制作一个副本
arr[ 1 ] = ' 大 ' ;
System . out . println (s1);
 
String s2 = new String (arr, 2 , 3 ); // 第 2 个参数是开始下标 , 第 3 个参数是长度
System . out . println (s2);
String s3 = new String (arr, 0 , arr. length );
System . out . println (s3);
}
 
@Test
public void test3 () {
String s1 = "atguigu" ;
String s2 = "java" ;
String s4 = "java" ;
String s3 = new String ( "java" );
System . out . println (s2 == s3);
System . out . println (s2 == s4);
System . out . println (s2. equals (s3));
 
String s5 = "atguigujava" ;
// 字符串拼接时 , 如果有变量参与 , 结果一定是新字符串对象 , 并且在堆 .
String s6 = (s1 + s2). intern (); // intern() 作用是把字符串塞入常量区中 , 如果常量区中已经有此对象了 , 则返回常量对象的地址 .
System . out . println (s5 == s6); // true
System . out . println (s5. equals (s6));
 
}
 
@Test
public void test2 () {
String s1 = new String ();
String s2 = "" ;
String s3 = null ;
 
System . out . println (s1 == s2);
System . out . println (s1. equals (s2));
 
String s4 = new String ( "qqq" );
 
 
}
 
@Test
public void test1 () {
String s1 = "abc" ;
s1 += "yyy" ;
System . out . println (s1);
}
}
 
 
作业一：
 
上一篇：初级快捷键，用idea开发必须会
下一篇：Java基础编程

发表评论

最新留言

逛到本站，mark一下
[***.202.152.39]2025年05月04日 11时54分24秒

关于作者

    喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！
-- 愿君每日到此一游！

推荐文章

支持对接禅道进行缺陷管理，MeterSphere开源持续测试平台v1.5.0发布丨Release Notes 2019-03-16
使用分享丨MeterSphere平台上的SSL证书配置 2019-03-16
【毕设-STM32f103寄存器版本】智能防盗系统 2019-03-16
Vue Itea软件里直接npm run build 报错npm ERR！ missing script :build 2019-03-16
勒索病毒Kraken2.0.7分析 2019-03-16
ACwing 858. Prim算法求最小生成树 2019-03-16
用心理解设计模式——桥接模式 / 桥梁模式 (Bridge Pattern) 2019-03-16
Java浅拷贝和深拷贝的区别和原因 2019-03-16
《动手学深度学习》(PyTorch版)代码注释 - 48 【Multi-scale_target_detection】 2019-03-16
MySQL错误1366处理方法 2019-03-16
Error running Address localhost:1099 is already in use（已解决） 2019-03-16
java.io.FileNotFoundException系统找不到指定文件(已解决) 2019-03-16
pytorch深度学习中每个epoch运行时间的统计代码 2019-03-16
ListView 2019-03-16
System.Timers.Timer定时器的使用 2019-03-16
手写Promise 2019-03-16
再发一篇---获取设备版本号方法！ 2019-03-16
eclipse启动出现“An Error has Occurred. See the log file”解决方法 2019-03-16
TCP&HTTP区别和联系 2019-03-16
RPC服务和HTTP服务对比 2019-03-16
白红宇的个人博客 - 记录点点滴滴的事 - 您是第 462632812 位访客
访问时间: 2025-05-10 06:08:48 访问IP: 18.118.207.174     Copyright © 2020 - 2025 css8.cn 京ICP备2021015314号-1 手机版