Java自学开工第五周

目录

第十一章：异常

第十二章：集合

第十三章：泛型

泛型类 ：

泛型接口：

泛型方法：

---

第十一章：异常

在程序中，错误可能产生于程序员没有预料到的各种情况，或者超出程序员可控范围的环境，例如用户的坏数据、试图打开一个不存在的文件等。为了能够及时有效地处理程序中的运行错误，Java 专门引入了异常类。

1.throw：就是手动抛出一个异常，并获取这个异常的引用，这个异常会被抛到外部的环境，由外部环境进行处理

class A{
	public void f() throws Exception
    {
        throw new Exception(); 
    } 
}

除了系统定义好的异常，用户还可以自己定义异常类型。定义方法如下：
自定义异常类，继承RuntimeException或Exception
定义重载构造函数，其中构造函数初始化异常信息

class IllegalAgeException extends RuntimeException
{
	IllegalAgeException(){ }
	IllegalAgeException(String msg)
	{
		super(msg);
	}
}
class Person
{
	Person(int a,String g,String n)
	{
		if(a > 150 || a < 1)
		{
			throw new IllegalAgeException("年龄范围不对！");
		}
		else
		{
            age = a;
        }
            gender = g;
            name = n;
	}
    public void setAge(int a)
    {
        if(a > 150 || a < 1)
        {
            throw new IllegalAgeException("年龄范围不对！");
        }
        else
        {
            age = a;
        }
    }
    private int age;
    private String gender;
    private String name;
}

public class Test
{
	public static void main(String agrs[])
	{
		try
        {
        	Person p2 = new Person(151,"male","chen");
        }catch(Exception e)
        {
			e.printStackTrace();
		}
	}
}

2.throws：其实并不是抛出一个实际的Exception, 而是一个异常声明，它声明这个方法可能会抛出一个异常，注意是可能，所以在没有异常的情况下也是可以用throws的，而throws本身的作用也是用来提高程

序的健壮性，相反，如果这个方法的的的确确有一个异常，那么编译器会强制让你加上throws这个异常声明。

3.try-catch-finally：

这个程序块分为三个部分try { }, catch( ){ }, finally{ }:

try块中放入的是可能出现异常的语句, 即可能抛出异常的程序段

catch(exception的引用)是用来处理try块里抛出的异常, catch参数列表中接受的是异常的引用(即throw抛出的异常对象的引用)

4.System.out.println(e)（异常信息的显示）

System.out.println(e)，打印异常类型

5.printStackTrace方法

try{
    
}catch(Exception e)
{
    e.printStackTrace();
}

第十二章：集合

Java集合类存放于 java.util 包中，是一个用来存放对象的容器。

注意：①集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入的，Java中每一种基本类型都有对应的引用类型。

　　　②集合存放的是多个对象的引用，对象本身还是放在堆内存中。

　　　③集合可以存放不同类型，不限数量的数据类型。

Java 集合框架图：https://img-blog.csdn.net/20160124221843905

集合与数组的区别：

①长度区别：集合长度可变，数组长度不可变

②内容区别：集合可存储不同类型元素，数组存储只可单一类型元素

③元素区别：集合只能存储引用类型元素，数组可存储引用类型，也可存储基本类型

Collection接口（单列集合）

Collection接口是单列集合的最顶层接口，定义了一些通用的方法。

add(E e)添加元素;  clear()清空元素;  remove(E e)移除元素;  size()元素数量;

toArray()集合转数组;  contains(E e)判断元素是否存在;  isEmpty()判断集合是否为空;

List 接口

元素有序，存储及取出时顺序一致；

元素可重复，通过.equals()比较是否重复。

它利用索引(index)，定义了一些特殊方法：

get(int index,E e) 获取指定位置的元素；remove(int index)移除指定位置的元素; 

add(int index,E e) 将元素添加到指定位置；set(int index,E e) 用元素替换指定位置的元素；

public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("George");
        list.add("Jim");
        list.add("Blake");
        list.add("Kevin");
        list.add("Mecheal");
        list.add("John");

        //for循环
        for (int i = 0; i < list.size(); i++) {
            String s =  list.get(i);
            System.out.println(s);
        }
        //foreach
        for (String s : list) {
            System.out.println(s);
        }
        //迭代器遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

Set接口：

特点：元素不可重复；

元素无序，存储及取出时顺序不一致；

没有索引，因此不能使用普通For循环遍历；

Set与Collection 接口中的方法基本一致，没有进行功能上的扩充；

public static void main(String[] args) {
        Set<String> list=new HashSet<>();
        list.add("George");
        list.add("Jim");
        list.add("Blake");
        list.add("Kevin");
        list.add("Mecheal");
        list.add("John");

        //foreach
        for (String s : list) {
            System.out.println(s);
        }
        //迭代器遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

 

Map接口（双列集合）

put(key , value) 添加元素； remove(key) 删除key对应元素；

containsKey(key) 判断是否存在key对应元素；get(key) 获取key对应元素；

KeySet() 获取所有的key，存到Set集合中；entrySet() 获取所有的元素，存到Set集合中；

  public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("name", "Tom");
        map.put("age", "20");
        map.put("address", "beijing");

        for (String key : map.keySet()) {
            String value = map.get(key);
            System.out.println(key+"==="+value);
        }

        Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> entry = iterator.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"==="+value);
        }

        for (Map.Entry<String,String> entry: map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"==="+value);
        }

        for (String value:map.values()) {
            System.out.println(value);
        }
    }

例：如何判断两个集合是否有交集，并打印出他们的交集

public static void main(String[] args) {
        HashSet<String> hs=new HashSet<String>();
        hs.add("George");
        hs.add("Jim");
        hs.add("Blake");
        hs.add("Kevin");
        hs.add("Mecheal");
        hs.add("John");

        HashSet<String> hs2=new HashSet<String>();
        hs2.add("George");
        hs2.add("Kate");
        hs2.add("Kevin");
        hs2.add("Mecheal");
        hs2.add("Ryan");

        hs.retainAll(hs2);
        if (hs.size()==0){
            System.out.println("没有交集");
        }else{
            System.out.println("有交集");
        }
        for (String s : hs) {
            System.out.println(s);
        }
    }

第十三章：泛型

泛型 ，顾名思义就是 广泛的数据类型，也就是说什么数据类型都可以。

一般来说，我们见到的泛型就是这个样子，用 T 表示。

如下所示，在类名后方申明泛型 T，接着就可以在成员变量、方法中使用泛型了。 

public class User<T> {
	
	private T name;
}

泛型类 ：

public class Pair<T> //引入类型变量T  这里就把类型给参数化了
{ 
//类定义中的类型变量指定方法的返回类型以及域和局部变量的类型
     private T first;
     private T second;
 
     public Pair() 
     {   
            first = null;
            second = null;
     }
 
     public Pair(T first, T second) 
     { 
        this,first = first;
        this.second = second; 
     }
 
    public T getFirstO { return first; } 
    public T getSecondO { return second; }
 
    public void setFirst(T newValue) { first = newValue; }
    public void setSecond(T newValue) { second = newValue; }

泛型接口：

//泛型接口，将泛型定义在接口上。 
 
interface Inter<T>{
	public void show(T t);
}
 
//泛型接口，将泛型定义在接口上。 
interface Inter<T>{
	public void show(T t);
}
 
 
class InterImpl2<Q> implements Inter<Q>
{
	public void show(Q  q){
		System.out.println("show :"+q);
}

泛型方法：

class ArrayAlg  //普通类 
 { 
     public static <T>  T getMiddle(T a)  //泛型方法  
 
     {
         return a[a.length / 2];
     }
 }