java学习第六天

2020-01-09 本文已影响0人 toro宇

异常处理

数组越界

空指针

错误运算

异常处理机制

屏幕快照 2020-01-08 下午5.36.49.png

package day10;

public class Test1 {
public static void main(String[] args) {
    Test11 two = new Test11();
    try {
        two.test();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
}

class Test11{
int i;
public void test() throws Exception{
    Test11 one = null;
    System.out.print(one.i);
}
}

屏幕快照 2020-01-09 上午9.53.16.png

屏幕快照 2020-01-09 上午10.14.25.png

java提供的异常类一般是够用了，只有特殊的情况可能需要自己编写异常类

集合

  // 如果想要让集合只能存同样类型的对象，怎么做
     //使用泛型
     Set<String> set1  = new HashSet<String>(); // 指定String为集合的泛型。 等号左边加的泛修饰的意思是在编译阶段就做限制。 右边是到运行时才生效的限制
     set1.add("df");

package day10;
import java.util.Comparator;
public class Persion implements Comparator<Persion>  {
int age;
String name;
public Persion() {
}
public Persion(int age, String name) {
    this.age = age;
    this.name = name;
}
@Override
public int compare(Persion o1, Persion o2) {
    // TODO Auto-generated method stub
//      return 0;
    if(o1.age > o2.age) {
        return 1;
    }else if(o1.age < o2.age) {
        return -1;
    }else {
        return 0;
    }
}
}

Set<Persion> set3 = new TreeSet<Persion>(new Persion());
     set3.add(new Persion(12,"lishi"));
     set3.add(new Persion(30,"wangwu"));
     set3.add(new Persion(14,"ll"));
     set3.add(new Persion(8,"hel"));
     
     for(Persion p : set3) {
         System.out.println("姓名：" + p.name + "---" + "年龄：" + p.age);
     }

package day10;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test4 {

public static void main(String[] args) {

List<Student> lists = new ArrayList<Student>();
lists.add(new Student("one",12));
lists.add(new Student("two",40));
lists.add(new Student("three",25));
lists.add(new Student("five",2));

for(Student t : lists) {
    System.out.println("name:" + t.name +"--"  + "age:" + t.age);
}
System.out.println("=======");
  Collections.sort(lists, new Paixu()); // 重新排序，传入要排序的集合及排序处理对象
for(Student t : lists) {
    System.out.println("name:" + t.name +"--"  + "age:" + t.age);
}
}
}

class Student{
String name;
int age;
public Student() {
    
}
public Student(String name,int age) {
    this.name = name;
    this.age = age;
}
}

class Paixu implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
    // TODO Auto-generated method stub
    if(o1.age > o2.age) {
        return 1;
    }else if(o1.age < o2.age) {
        return -1;
        
    }
    return 0;
}
}
// 输入结果
name:one--age:12
name:two--age:40
name:three--age:25
name:five--age:2
=======
name:five--age:2
name:one--age:12
name:three--age:25
name:two--age:40

泛型

当我们定义一个类可以处理任意类型的数据时，由于任何类型的数据(Object)都可被传入，则会导致类型安全问题，并且进行数据处理时还要进行类型强转.所以出现了泛型。用泛型定义可以接收任意类型的数据，而数据的类型，当具体操作时，根据当前操作数据的类型来具体定义即可。

泛型的使用

》泛型类

》泛型接口

public class Test6 {
public static void main(String[] args) {
    BI<String> bi = new BI<String>();
    bi.test("hh");
}
}

interface IB<T>{ // 泛型接口
T test(T t);
}

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声    明也一起加到类中
 *
 */
class BI<T> implements IB<T>{

@Override
public T test(T t) {
    // TODO Auto-generated method stub
    return t;
}

}

/**
 * 传入泛型实参
 */

class BI2 implements IB<String>{

@Override
public String test(String t) {
    // TODO Auto-generated method stub
    return null;
}

}

》泛型方法