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、二进制数操作
位运算符:& | ^ ~
移位运算符:
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;iget(i);
System.out.println("第"+(i+1)+"个名字是:"+temp.getName());
}
//从a1中删除一个对象
a1.remove(2);
System.out.println("=====删除后====");
for(int i=0;iget(i);
System.out.println("第"+(i+1)+"个名字是:"+temp.getName());
}
}
HashMap和Hashtable区别:
小结:如果要求数据量很大,又要线程安全考虑时用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 a1=new ArrayList();
//创建一只狗
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 gen1=new Gen(1);
// gen1.showTypeName();
Gen gen2=new Gen(new Dog());
gen2.showTypeName();
}
}
class Cat {
}
class Dog {
String name;
int age;
public void count() {
}
}
//定义一个类
class Gen {
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;iout.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");
}
}
*/