day04

JavaDay04总结

1、实现接口VS继承类：

1. 实现接口是继承的补充
2. 实现接口可以在不打破继承关系的前提下，对某个功能扩展

2、绑定：

1. 前期绑定：在程序运行前进行绑定，由编译器和连接程序实现，又叫静态绑定
2. 后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，又叫动态绑定

3、final：修饰变量或者方法

1. 当不希望父类的某个方法被子类覆盖时
2. 当不希望类的某个变量值被修改时
3. 当不希望被继承时

注意：final修饰的变量又叫常量，用xx_xx_xx命名，并且变量在定义时必须赋初值且不能修改
使用final：1.因安全考虑，类的方法不能被修改 2.类不会被其他类继承 3.某些变量值固定不变
4、数组：
1.定义：数据类型 数组名[]=new 数据类型[大小]; eg.int a[]=new int [5]; int a[]=int []a
2.引用：数组名[下标] a.length 计算数组大小
3.初始化数组：int a[]={1,2,3,4,5}; 相当于 int a[]=new int[5];a[0]=1;a[1]=2;...
数组小结：(1)数组可以存放同一类型数据 (2)简单数据类型数组可直接复制 (3)对象数组在定义后，赋值时需要再次为每个对象分配空间 (4)数组大小必须提前指定 (5)数组名为数组首地址的使用 (6)数组的下标从0开始
5、对象数组：

/*
作者：mys
功能：对象数组的使用
日期：2018/7/13
 */
package cn.mys;
import java.io.*;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Demo16 {
    public static void main(String []args) throws Exception
    {
        //定义一个可以存放四只狗的对象数组
        Dog dogs[]=new Dog[4];
        //从控制台输入各个狗的信息
        InputStreamReader isr=new InputStreamReader(System.in);
        BufferedReader br=new BufferedReader(isr);
        for(int i=0;i<4;i++)
        {
            dogs[i]=new Dog();//创建一个空间存放狗的具体信息
            System.out.println("请输入第"+(i+1)+"只狗的名字：");
            //从控制台读取狗名
            String name=br.readLine();//异常
            //将狗名赋给对象
            dogs[i].setName(name);

            System.out.println("请输入狗的体重：");
            //从控制台读取狗的体重
            String s_weight=br.readLine();
            //String->float
            float weight=Float.parseFloat(s_weight);
            //将狗体重赋给对象
            dogs[i].setWeight(weight);
        }
        //计算总体重
        float allWeight=0;
        for(int i=0;i<4;i++)
        {
            allWeight+=dogs[i].getWeight();
        }
        //计算平均体重
        float avrWeight=allWeight/dogs.length;
        System.out.println("总体重："+allWeight+" 平均体重："+avrWeight);
    }
}
class Dog
{
    private String name;
    private float weight;
    public void setName(String name)
    {
        this.name=name;
    }
    public String getName()
    {
        return name;
    }
    public void setWeight(float weight)
    {
        this.weight=weight;
    }
    public float getWeight()
    {
        return weight;
    }
}

6、二进制数操作

1. 二进制的最高位是符号位：0正数，1负数
2. 正数的原码、反码、补码一样
3. 负数的反码=原码符号位不变，其余位取反
4. 负数的补码=反码+1
5. 0的反码、补码=0
6. java的数都是有符号的
7. 计算机在运算时，都是以补码的方式

位运算符：& | ^ ~
移位运算符：

8. 算术左移<< ：符号位不变，低位补0（相当于*2）
9. 算术右移>> ：符号位不变，低位溢出，并用符号位补溢出高位
10. 逻辑右移>>>：低位溢出，高位补0

7、集合类：
分类

1. List集合类：ArrayList类、LinkedList类、Vector类、Stack类
2. Map集合类：HashMap类、Hashtable类
3. Set集合类：HashSet类、TreeSet类
4. Queue集合类：Queue接口

ArrayList和Vector区别：

1. 同步性：Vector同步，保证线程的安全性；ArrayList异步，线程并不安全但是效率高。
2. 数据增长：都使用数组来控制集合中的对象，当增加元素时，如果超出内部数组的目前长度，需要扩展，Vector在缺省的情况下自动增长为原来的一倍，ArrayList增长为原来的50%，若要在集合中保存大量数据，用Vector。

		//ArrayList使用
		//定义ArrayList对象
        ArrayList a1=new ArrayList();
        //显示大小
        System.out.println("加入前a1大小："+a1.size());
        //向a1中加入数据（类型是Object）
        //创建一个职员
        Clerk clerk1=new Clerk("mys",19,1000);
        Clerk clerk2=new Clerk("sky",20,1200);
        Clerk clerk3=new Clerk("lucy",20,900);
        //将clerk1加入到a1中
        a1.add(clerk1);
        a1.add(clerk2);
        a1.add(clerk3);
        a1.add(clerk1);//可以放入同样的对象
        //显示大小
        System.out.println("加入后a1大小："+a1.size());

        //访问a1中对象（数据）
        //Clerk temp=(Clerk)a1.get(0);//注意类型要匹配
        //System.out.println("第一个名字是："+temp.getName());

        //遍历a1所有对象
        for(int i=0;i<a1.size();i++)
        {
            Clerk temp=(Clerk)a1.get(i);
            System.out.println("第"+(i+1)+"个名字是："+temp.getName());
        }
        //从a1中删除一个对象
        a1.remove(2);
        System.out.println("=====删除后====");
        for(int i=0;i<a1.size();i++)
        {
            Clerk temp=(Clerk)a1.get(i);
            System.out.println("第"+(i+1)+"个名字是："+temp.getName());
        }
    }

HashMap和Hashtable区别：

1. 历史：Hashtable基于陈旧的Dictionary类，HashMap是java1.2引进的Map接口的实现
2. 同步性：Hashtable同步，HashMap异步
3. 值：HashMap可将空值作为一个表的条目的key或者value，Hashtable不能空放入值null

小结：如果要求数据量很大，又要线程安全考虑时用Vector；要求键值时用Hashtable或HashMap

		//HashMap、Hashtable使用
		//创建一个HashMap对象
        HashMap hm=new HashMap();
        Clerk clerk1=new Clerk("mys","m20172213",1000);
        //将clerk1放入hm
        hm.put("mys",clerk1);
        //如果要查找名为 mys
        if(hm.containsKey("mys")) {
            System.out.println("有该员工");
            //取出键值
            Clerk clerk=(Clerk)hm.get("mys");
            System.out.println("编号："+clerk.getNum());
        }
        else {
            System.out.println("没有该员工");
        }
        //遍历HashMap中所有的key和value
        //Iterator迭代
        Iterator it=hm.keySet().iterator();
        //hasNext返回一个Boolean
        while(it.hasNext()) {
            //取出key
            String key=it.next().toString();
            //通过key取出value
            Clerk clerk=(Clerk)hm.get(key);
            System.out.println("名字："+clerk.getName());
            System.out.println("编号："+clerk.getNum());
            System.out.println("薪水："+clerk.getSal());
        }
        //Hashtable不能放入空值,HashMap可以
        /*Hashtable ht=new Hashtable();
        ht.put(null,null);*/
        hm.put(null,null);
        System.out.println("测试："+hm.get(null));

8、泛型：本质：参数化类型，即所有的参数类型被指定为一个参数，可在类、接口和方法中创建，称为泛型类、泛型接口、泛型方法。安全简单，在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用性。
优点：1.类型安全 2.向后兼容 3.层次清晰 4.性能较高，用GL编写的代码可以为java编译器和虚拟机带来更多的类型信息，这些信息为java程序的进一步优化提供条件

/*
作者：mys
功能：泛型的使用
日期：2018/7/14
 */
package cn.mys;
import java.lang.reflect.Method;
import java.util.*;
import java.util.ArrayList;
public class Demo22 {
    public static void main(String []args) {
        //泛型
        ArrayList<Dog> a1=new ArrayList<Dog>();
        //创建一只狗
        Dog dog=new Dog();
        //放入集合
        a1.add(dog);
        //取出
        //Dog temp=(Dog)a1.get(0); 强制转换
        //Cat temp=(Cat)a1.get(0);//报错：ClassCastException，没有Cat对象
        //使用泛型后不用强制转换
        Dog temp=a1.get(0);

       // Gen<Integer> gen1=new Gen<Integer>(1);
       // gen1.showTypeName();
        Gen<Dog> gen2=new Gen<Dog>(new Dog());
        gen2.showTypeName();
    }
}
class Cat {

}
class Dog {
    String name;
    int age;
    public void count() {
    }
}
//定义一个类
class Gen<T> {
    private T o;
    public Gen(T a) {
        o=a;
    }
    //得到T的类型名
    public void showTypeName() {
        System.out.println("类型是："+o.getClass().getName());
        //通过反射机制，可以得到类型的很多信息，如成员函数名称
        Method []m=o.getClass().getDeclaredMethods();
        //打印
        for(int i=0;i<m.length;i++){
            System.out.println("成员函数名称："+m[i].getName());
        }
    }
}

9、异常：当出现程序无法控制的外部环境问题（用户提供的文件不存在、文件内容损坏、网络不可用...），java就会用异常对象来描述。
异常分类：
1.检查性异常：java.lang.Exception 程序正确，因外在环境条件不满足而引发
eg.用户错误及I/O问题----程序试图打开一个并不存在的远程Socket端口，或者打开不存在的文件时
2.运行期异常：java.lang.RuntimeException 程序存在bug eg.数组越界
3.错误：java.lang.Error 可能源于程序的bug或环境问题（一般），eg.内存耗尽，错误在程序中无需处理，有运行环境处理
顶层是java.lang.Throwable类，以上三种异常都是这个类的子类
异常处理：程序运行产生异常发生时，将从异常发生中断程序并向外抛出异常信息。在出现异常的地方，就终止执行代码，然后进入catch，如果有多个catch语句，则进入匹配异常的那个catch
异常处理方法：
1.在发生异常的地方直接处理
2.将异常抛给调用者，让调用者处理
finally：将finally块置于try...catch后，finally块一般会得到执行，相当于一个万能保险，即使前面的try块发生异常而又没有对应异常的catch块，finally块将被执行
多个异常的处理：子类异常的处理块必须在父类异常处理块的前面，否则会发生编译错误，因此越特殊的异常越在前面处理，越普遍的异常越在后面处理

/*
作者：mys
功能：异常及其处理、finally
日期：2018/7/14
 */
package cn.mys;
import java.io.*;
import java.net.*;
import java.io.FileReader;

public class Demo23 {
    public static void main(String []args){
        /*异常
        //检查异常
        //1.打开文件
        FileReader fr=new FileReader("d:\aaa.text");
        //2.连接一个192.168.1.1 IP端口号123
        Socket s=new Socket("192.168.1.1",123);

        //运行异常
        int a=4/0;//除数为0
        int b[]={1,2,3};
        System.out.println(b[10]);//数组越界
        */
        FileReader fr=null;
        try{
            //在出现异常的地方，就终止执行代码,然后进入catch
            //如果有多个catch语句，则进入匹配异常的那个catch
            Socket s=new Socket("192.1688.1.1",123);
            //FileReader fr=new FileReader("d:\aaa.text");
            fr=new FileReader("d:\aaa.text");
        }catch (Exception e){
            //把异常的信息输出，利于排除bug
            e.printStackTrace();
        }finally {
            //这个语句块，不管有没有异常都会执行
            //一般说，关闭需要的资源[文件，连接，内存]
            System.out.println("进入finally");
            if(fr!=null){
                try{
                    fr.close();
                    System.out.println("文件已关闭");
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}
/*将异常抛给调用者
class Father {
    private Son son=null;
    public Father() {
        son=new Son();
    }
    public void test1(){
        //son.test();//调用时出现异常
    }
}
class Son {
    //将异常处理抛出，给调用者
    public void test()throws Exception{
        FileReader fr=new FileReader("d:\aaa.text");
    }
}
*/