欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

day04

程序员文章站 2022-06-12 21:03:57
JavaDay04总结 1、实现接口VS继承类 : 1. 实现接口是继承的补充 2. 实现接口可以在不打破继承关系的前提下,对某个功能扩展 2、绑定 : 1. 前期绑定:在程序运行前进行绑定,由编译器和连接程序实现,又叫静态绑定 2. 后期绑定:在运行时根据对象的类型进行绑定,由方法调用机制实现,又 ......

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. 计算机在运算时,都是以补码的方式

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

  1. 算术左移<< :符号位不变,低位补0(相当于*2)
  2. 算术右移>> :符号位不变,低位溢出,并用符号位补溢出高位
  3. 逻辑右移>>>:低位溢出,高位补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");
    }
}
*/