JavaDay04总结
1、实现接口VS继承类：
- 实现接口是继承的补充
- 实现接口可以在不打破继承关系的前提下，对某个功能扩展
2、绑定：
- 前期绑定：在程序运行前进行绑定，由编译器和连接程序实现，又叫静态绑定
- 后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，又叫动态绑定
3、final：修饰变量或者方法
- 当不希望父类的某个方法被子类覆盖时
- 当不希望类的某个变量值被修改时
- 当不希望被继承时
注意：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、二进制数操作
- 二进制的最高位是符号位：0正数，1负数
- 正数的原码、反码、补码一样
- 负数的反码=原码符号位不变，其余位取反
- 负数的补码=反码+1
- 0的反码、补码=0
- java的数都是有符号的
- 计算机在运算时，都是以补码的方式
位运算符：& | ^ ~
移位运算符：
- 算术左移<< ：符号位不变，低位补0（相当于*2）
- 算术右移>> ：符号位不变，低位溢出，并用符号位补溢出高位
- 逻辑右移>>>：低位溢出，高位补0
7、集合类：
分类
- List集合类：ArrayList类、LinkedList类、Vector类、Stack类
- Map集合类：HashMap类、Hashtable类
- Set集合类：HashSet类、TreeSet类
- Queue集合类：Queue接口
ArrayList和Vector区别：
- 同步性：Vector同步，保证线程的安全性；ArrayList异步，线程并不安全但是效率高。
- 数据增长：都使用数组来控制集合中的对象，当增加元素时，如果超出内部数组的目前长度，需要扩展，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区别：
- 历史：Hashtable基于陈旧的Dictionary类，HashMap是java1.2引进的Map接口的实现
- 同步性：Hashtable同步，HashMap异步
- 值：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");
}
}
*/