11异常

1.1抛出

在代码可能出现异常的地方进行抛出异常

使用关键字：

  1. throw：在方法中抛出异常对象，自己造一个异常！！！
  3. shrows：在方法的声明位置去书写，告知调用者，当前抛出的异常有哪些。

编译时异常需要在方法名“后”加 throws，如果只是执行时异常，在方法“中”加throw

1.2自定义异常

自己建一个类，去继承Exception

  1. package com.qfedu.test1;
  3. //自定义异常
  4. public class Demo4 {
  5.     public static void main(String[] args) throws SingleDogException {
  6.         buy(false);
  7.         buy(true);
  8.     }
  9.     public static void buy(boolean isSingle) throws SingleDogException {
  10.         if (isSingle) {
  11.             throw new SingleDogException("单身狗不能进店");
  12.         }
  13.         System.out.println("情侣买一送一");
  14.     }
  15. }
  16. //自己定义一个异常继承父类
  17. class SingleDogException extends Exception{
  18.     public SingleDogException() {}
  19.     public SingleDogException(String message) {
  20.         super(message);//调用父类的有参构造
  21.     }
  22. }

throws是抛出，不管异常，运行报红。try catch还管管你

2.String 类

想要学习一个类：用api搜String，看类的关系和类下面的构造方法和方法

    • String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。

2.1判断两个字符串是否相同

Demo1

==： 比较的是内存地址和内容（严格）

    • boolean equals(Object anObject) 将此字符串与指定对象进行比较。

equals：a.equlas(“b”) 只比较内容（不严格）

以后开发中比较字符串，必须使用equlas

  1. package com.qfedu.test2;
  3. public class Demo1 {
  4.     public static void main(String[] args) {
  5.         //在栈区
  6.         String str1 = "abc";
  7.         String str2 = "abc";
  8.         //在堆区   new一个对象，就会产生不同的内存地址
  9.         String str3 = new String("abc");
  10.         String str4 = new String("abc");
  12.         //== 比较的是内存地址和内容 只要有一个不一样就为false
  13.         System.out.println(str1 == str2);//T
  14.         System.out.println(str1 == str3);//F
  15.         System.out.println(str3 == str4);//T
  16.         //a.equlas("b")  只比较内容
  17.         System.out.println(str1.equals(str3));//T
  18.         System.out.println(str3.equals(str4));//T
  19.     }
  21. }
  22. 输出：
  23. true
  24. false
  25. false
  26. true
  27. true

2.2获取字符串长度和特定位置字符

Demo2

获取字符串长度：int string.length();

获取特定位置字符：char string.charAt(a);//a索引位置的字符

获取特定字符的位置：int string.indexOf(“c”);//c字符的下标索引位置

获取最后一个字符的位置 :int lastIndexOF(int char);

  1. package com.qfedu.test2StringClass;
  2. //返回字符串长度的方法、具体位置的字符、特定字符的位置
  3. public class Demo2 {
  4.     public static void main(String[] args) {
  5.         String string = "abcdefcg";
  6.         //字符串的长度
  7.         System.out.println(string.length());//8
  9.         //获取字符串中索引为2的字符
  10.         System.out.println(string.charAt(2));//c
  12.         //返回指定自字符串第一次出现的字符串内的索引。 
  13.         System.out.println(string.indexOf("g"));//7
  14.         //indexOf(int i)  括号里可以填字符  ascall码
  15.         System.out.println(string.indexOf('g'));//7
  17.         //返回指定自字符串最后一次出现的字符串内的索引。
  18.         System.out.println(string.lastIndexOf('c'));//6
  20.         //没有ac相连，输出-1
  21.         System.out.println(string.indexOf("ac"));//-1
  22.         //0，有ab相连的，看第一个字符
  23.         System.out.println(string.indexOf("ab"));//0
  24.     }
  26. }
  27. 输出：
  28. 8
  29. c
  30. 7
  31. 7
  32. 6
  33. -1
  34. 0

Demo3

以特定字符结尾：string.endsWith(“.java”); //是否以.java结尾，返回值布尔

判断字符串是否为空：string.isEmpty() //空为T 不空为F,返回值布尔

判断字符串是否包含：string.contains(“mo3”)//包含为T,返回值布尔

判断字符串是否相同：equals(String string)//返回值布尔

忽略大小写，判断两个字符串是否相等：”abc”.equalsIgnoreCase(“ABC”)

  1. package com.qfedu.test2;
  2. //以上方法 
  3. public class Demo3 {
  4.     public static void main(String[] args) {
  5.         String string = "demo3.java";
  6.         //是否以.java结束
  7.         System.out.println(string.endsWith(".java"));//T
  8.         System.out.println("-------------");
  10.         //字符串是否为空
  11.         System.out.println(string.isEmpty());//f
  12.         System.out.println("".isEmpty());//T
  13.         System.out.println("  ".isEmpty());//F 空格也是字符串，
  14.         System.out.println("-------------");
  16.         //字符串是否包含 必须相连的
  17.         System.out.println(string.contains("mo3"));//T 包含
  18.         System.out.println("-------------");
  20.         //忽略大小写，判断两个字符相对
  21.         System.out.println("abc".equals("ABC"));//F  equals 不忽略大小写
  22.         System.out.println("abc".equalsIgnoreCase("ABC"));// T   不区分大小写
  23.     }
  25. }
  26. 输出：
  27. true
  28. -------------
  29. false
  30. true
  31. false
  32. -------------
  33. true
  34. -------------
  35. false
  36. true

2.3将字符数组转为字符串

Demo4

String的构造方法

new String（char[] char）;//将字符数组转为字符串

new String（char[] char, int offset, int count）; offset偏移量 count数量

static valueOf（char[] char）; 静态方法 直接String.valueOf(ch2)

将字符串转为字符数组

char[] toCharArray();//把字符串变成字符数组 用for依次遍历方便看出效果

  1. package com.qfedu.test2StringClass;
  3. import java.util.Arrays;
  5. public class Demo4 {
  6.     public static void main(String[] args) {
  7.         //将字符数组转为字符串
  8.         char[] ch1 = {'朱','志','伟'};
  9.         String string = new String(ch1);
  10.         System.out.println(string);
  12.         //将字节数组转为字符串 会乱码
  13.         byte[] by1 = {1,2,3};
  14.         String string2 = new String(by1);
  15.         System.out.println(string2);//会乱码
  17.         //偏移量
  18.         char[] ch2 = {'朱','志','伟','z','z','w'};
  19.         //2：offset 偏移量 在左边开始，偏移过去2个数（从下标为2开始）
  20.         //3：count 数量    取3个数据
  21.         String string3 = new String(ch2, 2, 3);
  22.         System.out.println(string3);//伟zz
  24.         //valueOf是静态方法，可以直接类名调用,返回值是String
  25.         System.out.println(String.valueOf(ch2));
  27.         //把字符串变成字符数组
  28.         char[] ch3 = "天气忽冷忽热".toCharArray();
  29. //        System.out.println(Arrays.toString(ch3));
  30.         for (int i = 0; i < ch3.length; i++) {
  31.             System.out.print(ch3[i] + "\t");
  32.         }
  33.     }
  35. }
  36. 输出：
  37. 朱志伟
  38. ？？？（乱码）
  39. 伟zz
  40. 朱志伟zzw
  41. 天    气    忽    冷    忽    热

Demo5zhongdian

以下相对重要，，开发中要用！！！！！！

字符串替换：

String replace（char oldchar,char newchar）//把字符串中某个地方替换

切割：

String[] split(String regex); 以某字符串开始切割，切割成字符串数组

截取：

String subString（int beginIndex）

String subString（int beginIndex ，int endIndex）

大小写转化：

String toUpperCase(); 小转大

String toLowerCase(); 大转小

去除首位空格（只能去除首位的）

trim();

  1. package com.qfedu.test2StringClass;
  3. import java.util.Arrays;
  5. public class Demo5zhongdian {
  6.     public static void main(String[] args) {
  7.         //字符串替换 所有的都换
  8.         System.out.println("abecdefg".replace("e", "换"));
  9.         System.out.println("abcdefgcd".replace("cde", "换三个"));
  11.         //切割
  12.         String string1 = "哈哈1,呵呵1,嘿嘿1";
  13.         //要求以逗号","开始切割  ==》{"哈哈"},{"呵呵"},{"嘿嘿"}
  14.         String[] str1 = string1.split("1");
  15.         System.out.println(Arrays.toString(str1));
  16.         for (int i = 0; i < str1.length; i++) {
  17.             System.out.print(str1[i] + "\t");
  18.         }
  19.         System.out.println();
  21.         //截取
  22.         String string2 = "abcdefg".substring(2);
  23.         System.out.println(string2);//cdefg  下标为2以前的东西不要
  25.         //第一个参数是开始截取的索引 、第二个参数是结束截取的索引
  26.         //截取是“要头不要尾”，“左开右闭”
  27.         String string3 = "ABCDEFGH".substring(2, 5);
  28.         System.out.println(string3);//CDE
  30.         //大小写字母转换
  31.         //小转大
  32.         System.out.println("abcAA".toUpperCase());
  33.         //大转小
  34.         System.out.println("QWEaa".toLowerCase());
  36.         //去除空格（只能去除首位的）
  37.         System.out.println("  QWE  asd  ");
  38.         System.out.println("  QWE  asd  ".trim());
  39.     }
  40. }
  41. 输出：
  42. ab换cd换fg
  43. ab换三个fgcd
  44. [哈哈, ,呵呵, ,嘿嘿]
  45. 哈哈    ,呵呵    ,嘿嘿    
  46. cdefg
  47. CDE
  48. ABCAA
  49. qweaa
  50.   QWE  asd  
  51. QWE  asd

3.泛型【重点】

3.1为什么要使用泛型

java1.5之后新的知识点，用来约束当前集合中的数据类型的

泛型：广泛的类型

在实际的开发中对数据一致性的要求是很重要的

例如：集合就是往里面存数据的

  1. package com.qfedu.test3fanxing;
  3. import java.util.ArrayList;
  5. //泛型 -- 用来约束当前集合中的数据类型的
  6. public class Demo1 {
  7.     public static void main(String[] args) {
  8.         //在真是的开发中对数据一致性的要求是很重要的
  9.         //比如数组，往数组里面存数据的时候，数据类型都是一致的
  10.         int[] arr = {15,94,-22};//存的数据都是int 一致的
  11.         //开发中很少使用数组！为啥？需要初始化容量，有局限性
  12.         //开发中使用集合来代替数组，集合也是用来存数据的
  14.         //空的集合，里面可以存数据
  15.         ArrayList list = new ArrayList();
  16.         list.add("伍兹");
  17.         list.add(24);
  18.         list.add(true);
  19.         list.add('人');
  20.         System.out.println(list);
  21.         //发现集合中的数据类型不一样！！不好
  22.         //从集合中往外取数据
  23.         Object object = (String)list.get(0);
  24.         System.out.println(object);
  25.         //涉及到强转，效率低还可能出错
  27.         //java从1.5版本加上泛型，用来约束当前集合中的数据类型的
  28.         ArrayList<String> list1 = new ArrayList<String>();
  29.         //加上泛型以后，这个集合只能存String类型的数据，保持数据一致性
  30.         list1.add("嗯");
  31.         list1.add("昂");
  32.     }
  33. }

3.2自定义泛型，在方法中如何书写

语法格式：

无意义的占位符：可以是T，可以是E，也可以是？。只是一个占位，没有实际的意义

  1. 权限修饰符  <无意义的占位符>  返回值 方法名字(){}
  2. public <?> void 方法名字(){}

无参数无返回值的方法：可以不加泛型，体现不到泛型的用处

有参数无返回值的方法：有必要使用泛型的

无参数有返回值的方法：没有参数没有意义，

有参数有返回值的方法

特点：

泛型方法只有带参数才能使用泛型，泛型才具有真正的意义

而且带有参数和返回值的方法，具有很大的局限性（只能传一个参数）！！！

  1. package com.qfedu.test3fanxing;
  3. public class Demo2 {
  4.     public static void main(String[] args) {
  5.         test("abc");
  6.         test(123);
  8.         //泛型   
  9.         test1(98.7);
  10.         test1("泛型");
  11.         test1(true);
  12.         //无参无返回值
  13.         test2();
  14.         //有参无返回值
  15.         test3(1, 3);
  16.         test3("朱", 1);
  17.         test3(true, 'z');
  18. //        //无参有返回值
  19. //        System.out.println(test4());
  21.         //有参有返回值
  22.         System.out.println(test5("狗蛋"));
  23.         System.out.println(test5(30));
  24.     }
  26.     public static void test(String string) {
  27.         System.out.println(string);
  28.     }
  30.     public static void test(int int1) {
  31.         System.out.println(int1);
  32.     }
  34.     //泛型的写法 <T> T可以随便改变 告知编译器当前方法带有泛型  
  35.     //这个参数(T t)  T 会根据你传入的实参的数据类型而随时变化
  36.     public static <T> void test1(T t) {
  37.         System.out.println(t);
  38.     }
  40.     //无参无返回值，没有体现泛型的用处
  41.     public static <T> void test2() {
  42.         for (int i = 0; i < 2; i++) {
  43.             System.out.print("zzw");
  44.         }
  45.         System.out.println();
  46.     }
  48.     //有参无返回值，有必要使用泛型
  49.     public static <T> void test3(T t,T a) {
  50. //        System.out.println(t + a);//不确定什么类型不能直接相加
  51.         System.out.println(t + "：" + a);
  52.     }
  54. //    //无参有返回值  
  55. //    // T代表返回值类型  T不能具体代表那一个类型，没有参数没有意义
  56. //    public static <T> T test4() {
  57. //        return (T) "返回谁呢";
  58. //    }
  60.     //有参有返回值,
  61.     public static <T> T test5(T t) {
  62.         return t;
  63.     }
  64. }

3.3泛型类如何书写【重点】

语法格式：无意义占位符T用的偏多

  1. class 类名<无意义的占位符>{
  2.     //泛型类的方法不用加<T>
  3.     //在main方法中 new的时候加具体的<数据类型>
  4.     //Person<String> person = new Person<String>();
  5. }

以后开发中很少用泛型类，架构师要写泛型类！！！！

  1. package com.qfedu.test4fanxingClass;
  3. //泛型类
  4. class Person<T>{
  5.     //泛型类下面的方法
  6.     //可以写正常的方法
  7.     public void eat() {
  8.         System.out.println("泛型类下可以写正常的方法,正常用正常调用");
  9.     }
  11.     //带泛型的方法
  12.     //在泛型类上面已经定义好T，在方法中就不用在写<T>了
  13.     //如果写了<T> 这个方法就是使用了自己的T的泛型，不是当前类的那个泛型
  14. //    public <T> void printArgs(T t) {//打印参数
  15. //        System.out.println(t);
  16. //    }
  17.     //方法的T 随着类的T的改变而改变
  18.     public void printArgs(T t) {//打印参数
  19.         System.out.println(t);
  20.     }
  22.     //写一个静态方法
  23.     //静态的方法  类是没有办法约束的  (T t) 这个T和类的T没关系了
  24.     //只能在创建对象的时候才能对对象进行约束
  25.     //静态方法早于对象的创建的，对象约束不了静态方法
  26.     public static <T> void staticTest(T t) {
  27.         System.out.println();
  28.     }
  29. }
  30. public class Demo1 {
  31.     public static void main(String[] args) {
  32. //        Person<String> person = new Person<String>();
  33.         Person person = new Person();
  34.         person.eat();
  36.         //声明的时候确定数据类型，调用时只能用这个数据类型
  37.         Person<String> person2 = new Person<String>();
  38.         person2.printArgs("a");
  39. //        person2.printArgs(45);//只能是String
  41.         Person<Integer> person3 = new Person<Integer>();//只能是integer
  42.         person3.printArgs(15);
  44.     }
  46. }

注意【静态方法】：

  1.     //在泛型类中
  2.     //静态的方法  类是没有办法约束的  (T t) 这个T和类的T没关系了
  3.     //只能在创建对象的时候才能对对象进行约束
  4.     //静态方法早于对象的创建的，对象约束不了静态方法
  5.     public static <T> void staticTest(T t) {
  6.         System.out.println();
  7.     }

3.4接口泛型如何书写

语法格式：

  1. interface 接口名字<无意义占位符>{
  3. }
  1. package com.qfedu.test5fanxingjiekou;
  3. //泛型接口
  4. interface A<T>{
  5.     //成员方法
  6.     public void test(T t);
  7. }
  8. //接口带有泛型，那么实现类也必须带有泛型
  9. class TestA<T> implements A<T>{
  11.     @Override
  12.     public void test(T t) {
  13.         // TODO Auto-generated method stub
  14.         System.out.println(t);
  15.     }
  16. }
  18. public class Demo1 {
  19.     public static void main(String[] args) {
  20.         TestA<String> testA = new TestA<String>();
  21.         testA.test("只能传String");
  22. //        testA.test(18);//只能传String数据类型的
  24.         TestA<Integer> testA1 = new TestA<Integer>();
  25.         testA1.test(18);
  26.     }
  27. }

3.4泛型抽象类如何书写

语法格式

  1. abstract class 类名<无意义占位符>{
  2.     //抽象方法
  3. }
  4. 继承抽象类
  5. class 类A <T> extends 抽象类<T>{
  6.     //重写方法
  7. }
  1. package com.qfedu.test6fanxingchouxiangClass;
  3. //泛型抽象类
  5. abstract class A<T>{
  6.     //成员方法
  7.     public abstract void test(T t);
  8. }
  10. class TestA<T> extends A<T>{
  12.     @Override
  13.     public void test(T t) {
  14.         // TODO Auto-generated method stub
  15.         System.out.println(t);
  16.     }
  18. }
  19. public class Demo1 {
  20.     public static void main(String[] args) {
  21.         TestA<String> testA = new TestA<String>();
  22.         testA.test("抽象类");
  23.     }
  24. }