Java学习笔记
2014-03-08 11:21
295 查看
一、8种数据类型
1字节(byte)=8个位bit
自动类型转换: byte\short\int->float->long->double， byte\short\int不互相转换，三者计算时会转换成int类型
强制类型转换 long g=1000L int
i=(int)g 布尔类型不能转换成其他任何数据类型
二、关键字
三、数组
int x[];
int[] x=new int[3]
int[] x=new int[]{3,4,5}
int[] x={1,2,3,4}
多维数组 int[] x=new int[3][4];
四、面向对象
构造方法： Duck d=new
Duck(); 如果存在多参数的时候 默认会覆盖无参的，如果需要则必须写出来（默认开发的话保留初始化构造方法）
方法重载：方法名相同，参数有多个，参数顺序不同函数不同
方法重写：
1.发生方法重写的两个方法返回值，方法名，参数列表必须完全一致（子类重写父类的方法）
2.子类抛出的异常不能超过父类相对应方法抛出的异常(子类异常不能大于父类异常)
3.子类的方法访问级别不能低于父类相应方法的访问级别（子类访问级别不能低于父类访问级别）
匿名对象：new Duck().func(); 特点只能使用一次，只使用一次对象，即可这样使用，直接在堆内存中开辟空间，会被GC回收，不易多次使用，以免产生垃圾
String类两种赋值:
String s1=new String("abc"); //会创建2个字符串对象，一个是堆内存new
String("abc"),一个是创建字符串常量池对象
String s2="abc" //这里先去字符串常量池查找有没有“abc”,如果没有就在字符串常量池创建，并指向常量池字符串
String类编译期和运行期：
1
String a="a1"; 编译期就确定了值
String a1="a"+1; 编译期确定了值 //a==a1
true
2
String b="b1"; 编译期就确定了值
int bb=1; 编译期确定了值
String b1="b"+bb; 编译期无法确定值，bb是个变量，只有到运行期才能确定具体值 //b==b1
flase
3
String c="c1"; 编译期就确定了值
final int cc=1; 编译期确定了值
String c1="c"+cc; 编译期CC已被常量1替换，所以确定具体值 //c==c1
true
4
String d="d1"; 编译期就确定了值
final int dd=getDD(); 编译期无法确定
String d1="d"+dd; 编译期dd函数还没有被指向，必须到运行期dd才能被函数的返回值1替换成常量，所以确定具体值 //d==d1
true
Static关键字（静态数据不是属于对象，属于类）
static修饰的变量 存放在内存方法区，在内存里面只创建一份数据
static方法里面不能调用this、super类对象关键字
static只能修饰内部类
五、对象数组
class ObjArray
{
public static void main(String[] args)
{
ManageMonkey mm=new ManageMonkey();
mm.add(new Monkey("张三",'m'));
mm.add(new Monkey("李四",'w'));
mm.add(new Monkey("王五",'m'));
mm.add(new Monkey("cc",'m'));
mm.list();
System.out.println("##############################");
/*Monkey m=mm.find("张三");
m.print();
System.out.println("##############################");
mm.edit("李四",'女');
mm.list();
System.out.println("##############################");*/
mm.del("cc");
mm.list();
}
}
//管理猴子类
class ManageMonkey
{
private Monkey[] mokenys=new Monkey[4];
private int count=0; //当前对象个数
public ManageMonkey(){}
//添加对象
public void add(Monkey m){
if(count<mokenys.length){
mokenys[count]=m;
count++;
}else{
System.out.println("对象数组已满");
}
}
//删除对象
public void del(String name){
for(int i=0;i<count;i++){
if(mokenys[i].getName().equals(name)){
for(int j=i;j<count-1;j++){
mokenys[j]=mokenys[j+1];
}
}
mokenys[count-1]=null;
count--;
}
}
//查找对象
public Monkey find(String name){
for(int i=0;i<count;i++){
if(mokenys[i].getName().equals(name)){
return mokenys[i];
}
}
return null;
}
//修改对象
public void edit(String name,char sex){
Monkey m=find(name);
m.setSex(sex);
}
//打印数组对象
public void list(){
for(int i=0;i<count;i++){
mokenys[i].print();
}
}
}
//猴子对象
class Monkey
{
private String name;
private char sex;
public Monkey(){}
public Monkey(String name,char sex){
this.name=name;
this.sex=sex;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setSex(char sex){
this.sex=sex;
}
public char getSex(){
return sex;
}
public void print(){
System.out.println("name="+name+",sex="+sex);
}
}
六、foreach使用（只适合遍历，不适合android这样对内存要求比较高的开发，因为他会不断的产生内存对象）
可变参数用法（参数列表里面只能有一个可变参数，并且可变参数只能在最后一个）
method (int num,String... names){
for(String name:names){
System.out.print(name);
}
}
调用的
method("123","cvb","qw","fgh");
七、代码块
1、普通代码块：在方法中使用，作用域只在最近的{}内
2、构造代码块：在构造对象时调用，在类中的代码块，先于构造方法执行
3、静态代码块：在构造代码块前加上static,在类加载时只执行一次
八、单例设计模式（面试）[构造方法私有化，静态方法获取对象]
饿汉式
class Singleton
{
private static Singleton s=new Singleton();
private Singleton(){}
public static Singleton getInstans(){
return s;
}
public void print(){
xxxxx
}
}
懒汉式
class Singleton
{
private static Singleton s=null;
private Singleton(){}
public static Singleton getInstans(){
if(s==null){
s=new Singleton();
}
return s;
}
public void print(){
xxxxx
}
}
八、final关键字
1.final声明一个类，该类不能被继承
2.final声明一个方法，该方法不能被子类重写
3.final声明一个常量，如果数据类型是 类类型，那么地址不能变
九、抽象类（abstract）
抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
非抽象类继承抽象类的时候，必须实现抽象类里面的所有抽象方法
抽象类可以有方法和属性
抽象类不能被实例化
抽象类不能被final
十、接口
interface hit{
public void cry()
}
class god implements his{
}
1.接口可以继承多个
2.一个类可以实现多个接口
3.抽象类实现接口可以不实现接口里面的方法
4.接口中所有的方法全部是public
5.接口中所有的属性都是常量而且是静态的
十一、多态
向上转型：将子类实例转为父类实例 格式：父类 父类对象=子类实例 (new 谁就调用谁的方法)
向下转型：子类对象转变成父类 格式:子类 子类对象=（子类）父类实例
多态性:
1.方法的重载与重写就是方法的多态性表现
2.多个子类就是父类中的多种形态
3.父类引用可以指向子类对象，自动转换
4.子类对象向父类引用需要强制转换（注意：类型不对会报异常）
5.在实际开发中尽量使用父类引用（更利于扩展）
十二、内部类
12.1 成员内部类
Outer out=new Outer(); //产生外部类
Outer.Inner in=null; //声明内部类对象
in=out.new Inner();//创建内部类实例
12.2 方法内部类
//方法内部类只能在该类方法里面实例化（作用域决定）
func (){
class Inner{
funcInner(){}
}
Inner i=new Inner();
i.funcInner();
}
//方法内部类对象不能使用该内部类所在方法的非final局部变量
//局部变量的属性生命周期没有内部类的生命周期长
func (){
int x=10; //Q1 final int x=10;
class Inner{
funcInner(){
System.out.println("x="+x); //Q1 此时这里的x 必须定义为final
}
}
Inner i=new Inner();
i.funcInner();
}
12.3静态内部类
//静态内部类只能访问静态属性
外部实例化 静态内部类 Outet.Inner oi=new Outet.Inner(); //一个静态内部类 相当于外部类
12.4 匿名内部类
原则：
1.不能有构造方法，只能有一个实例
2.不能定义任何静态成员、静态方法
3.不能是public\protece\private\static
4.一定是在new的后面，用其隐含实现一个接口或实现一个类
5.匿名内部类为局部的，所以局部内部类的所有显示都对齐生效
12.4-1继承式匿名内部类
main:
Dog d=new Dog(){
public void say(){}
};
d.say();
12.4-2接口式匿名内部类
interface Child{
public void say();
}
main:
Child c=new Child(){
public void say();
};
c.say();
12.4-3参数式匿名内部类
interface Child{
public void say();
}
main:
func(new Child(){
public void say(){xxxxxx}
});
public static void func(Child c){
c.say();
}
十三、链表
class LinkList //链表类demo
{
public static void main(String[] args)
{
NodeMange nm=new NodeMange();
nm.addNode("节点1");
nm.addNode("节点2");
nm.addNode("节点3");
nm.addNode("节点4");
nm.addNode("节点5");
nm.printNode();
nm.delNode("节点3");
nm.printNode();
}
}
//链表节点管理
class NodeMange{
private Node root;//根节点
//添加节点
public void addNode(String name){
//判断根节点是否为空
if(root==null){
root=new Node(name);
}else{
root.add(name);
}
}
//删除节点
public void delNode(String name){
if(root!=null){
if(root.name.equals(name)){
root=root.next;
}else{
root.del(name);
}
}
}
//打印节点
public void printNode(){
if(root!=null){
System.out.print(root.name);
root.print();
System.out.println();
}
}
//定义节点内部类
class Node{
//节点名称
private String name;
//表示下一个节点对象
private Node next;//把自己的类型作为属性类型（单向链表）
public Node(String name){
this.name=name;
}
//添加节点
public void add(String name){
if(this.next==null){
this.next=new Node(name);
}else{
this.next.add(name);
}
}
//删除节点
public void del(String name){
if(this.next!=null){
if(this.next.name.equals(name)){
this.next=this.next.next;
}else{
this.next.del(name);
}
}
}
//输出节点
public void print(){
if(this.next!=null){
System.out.print("-->"+this.next.name);
this.next.print();
}
}
}
}
十四、数据类型包装类
1.基本数据类型包装类
Number:Integer、Short、Long、Double、 Float 、Byte都是Number的子类表示是一个数字
Object:Character、Boolean都是Object的直接子类
2.装箱及拆箱操作（将基本数据类型转换为包装类即装箱，将一个包装类转换为基本数据类型即拆箱）
Integert x=10 (当直接赋值是，当值为1个字节内的数时，将使用同一个对象)【-128~127】
十五、异常处理
1.try{
//有可能发生异常的代码段
}catch(异常类型对象a){
//异常处理的操作
}catch(异常类型对象b){
//异常处理的操作
}
父类异常应该写在最下面，优先匹配子类异常
finally 即使return了 finally也会先执行了 在执行return
2.throw与throws
public class ExceptionDemo2 {
public static void main(String[] args) {
try{
add();
}catch(Exception ex){
ex.printStackTrace();
}
}
public static int add()throws Exception{
Scanner input =new Scanner(System.in);
try{
System.out.println("请输入第一个数：");
int num1=input.nextInt();
System.out.println("请输入第二个数：");
int num2=input.nextInt();
return num1+num2;
}catch(Exception ex){
throw new Exception("加法运算异常");
}finally{
System.out.println("运算结束");
}
}
}
十六、StringBuffer类
对于字符串管理比String类更高效，StringBuffer[适合多线程]和StringBuilder[适合单线程]
十七、国际化（locale类）
可以在IE浏览器属性语言里面找到对应的语言编号
Locale local=new Locale("zh","CN");
Locale local2=Locale.US; //代码常量
Locale local3=Locale.getDefault(); //根据系统默认语言环境
定义语言包 后缀 *.properties
info_zh_CN.properties
username=xxxxx
调用
ResourceBundle res=ResourceBundle.getBundle("com.vine.i18n.info",locale);
String username=res.getString("username");
处理动态文本
username=xxxxx {0}//占位符 xxx.[admin]谁登陆就显示谁
MessageFormat.format(username,'admin');
十八、常用工具类
Math数学类，Random随机数类，Array数组类，Date日期类，Calendar日历类，DataFormat和SimpleDateFormat日期格式化类
十九、对象比较器
自定义对象如果排序，必须实现Comparable接口compareTo方法
Class Persion implements Comparable<Person>
public int compareTo(Person o){
if(o==null){
throw new NullpotionException();
}
return 0;
if(this.age>o.age){
retuen 1;
}else if(this.age<o.age){
return -1
}
}
或者 自定义比较器类
Class PersionComparable implements Comparable<Person>{}
Arrays.sort(Person,PersionComparable );
二十、对象的克隆
在Object对象中存在一个clone()方法，如果某个类的对象想要被克隆，则对象所在的类必须实现Cloneable接口，此接口没有定义任何方法，是一个标记接口
二十一、IO
1.File类 目录遍历和文件遍历
2.字节输出流 outputStream os=new FileOutputStream类
//文件写入
3.字节输入流 InputStream in = new FileInputStream("g:\\1.txt"); //文件读取
4.字符输出流
public static void write1() {
File f = new File("g:\\1.txt");
try {
//构造一个字符输出流对象
Writer w = new FileWriter(f,true);
String info="好好学习,天天向上";
w.write(info);
w.close();
} catch (IOException e) {
e.printStackTrace();
}
}
5字符输入流 （这样防止乱码，文本文件适合）
public static void reader1() {
File f = new File("g:\\1.txt");
try {
Reader in = new FileReader(f);
char[] cs = new char[20];
int len = -1;
StringBuffer sb = new StringBuffer();
while ((len = in.read(cs)) != -1) {
sb.append(new String(cs, 0, len));
}
in.close();
System.out.println(sb);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
6.对象序列化（对象必须实现seralizable接口才能被序列化）
7.字节数组流
二十二、集合框架
二十三、线程和进程
线程是进程的进一步划分，一个程序可以看做是一个进程，执行过程可以可以划分多个线程，线程之间可以互相切换
多线程的实现方式
1.继承Thread类 ------myThread.start()启动线程
2.实现Runnable接口run方法 //更推荐使用runnable方法启动线程，自定义类的话继承的话受限于Threadf单继承
MyRunnabe mr=new MyRunnabe();
Thread t=new Thread(mr);
线程同步机制
object obj=new Object();
方式一 ：synchronized（obj）{
同步代码块
}
方式二：public function synchronized run(){
同步代码块
}
二十四、反射
Java的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object
二十五、內省机制
内省(IntroSpector)是Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性，这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，通过这些 API 可以使你不需要了解这个规则（但你最好还是要搞清楚），这些 API 存放于包 java.beans 中,一般的做法是通过类 Introspector
的 getBeanInfo方法 来获取某个对象的 BeanInfo 信息,然后通过 BeanInfo 来获取属性的描述器(PropertyDescriptor),通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法,然后我们就可以通过反射机制来调用这些方法。
JavaBean 必须含有get\set方法
相关API：IntroSpector 、BeanInfo、Properties（负责读取*.properties文件）
二十六、泛型
1、泛型
2、通配符
public void method(Person<?> p){
P.getAge(); 只能调用，不能修改
}
上限： public class Person<T extends Number>{} //必须是Number的子类
下限:public function method(Person<? super String> p){} //必须是string的父类
3、泛型接口
public interface Test<T>{
public void eat(T e);
}
4、泛型方法
public static <T>T[] func(T[] array,int i,int t){ //泛型方法2个数组换位置
T temp=array[i];
array[i]=array[t];
array[t]=temp;
return array;
}
5、泛型嵌套使用
Set<Entry<Integer,String>> entrys=map.entryset();
二十七、枚举
1.Enum类与enum关键字
使用enum关键字，实际就是定义了一个Enum类的子类
class enum EnumController{
ON,OFF
}
EnumController econ=EnumController.ON;
2.集合对枚举的支持
EnumSet\Enummap
3.带构造方法的枚举(不能在外面定义对象)
class enum EnumGril{
Gril1,Gril2;//这个一定要最前面
private String name;
private EnumController(){}
}
main:
EnumGril egs=EnumGril.Gril1;
这样调用的都是无参的的构造方法
class enum EnumGril{
Gril1("xuchen"),Gril2("abc");//这样调用的就是有参的构造方法
private String name;
private EnumController(){}
private EnumController(String name){}
}
main:
EnumGril egs=EnumGril.Gril1;
这样调用的都是有参的构造方法
4.让枚举实现接口 //不能继承类，因为enum关键字已经隐式继承了Enum类
interface Info{
public String getColor();
}
class enum EnumColor implemetns Info{
Red{
public String getColor(){ return "red"}
},Blue{
public String getColor(){ return "blue"}
},Green{
public String getColor(){ return "green"}
}
}
5.在枚举中定义抽象方法
class enum EnumController {
ON{
public EnumController downAction(){
return OFF;
};
},OFF{
public EnumController downAction(){
return ON;
};
}
public abstract void downAction();
}
二十八、XML解析
使用DOM解析XML
SAX解析XML
GUI插件是VE插件
1字节(byte)=8个位bit
| 数据类型 | 关键字 | 占用字节 | 取值范围 | 默认值 |
| 布尔型 | Boolean | 1 | True,false | false |
| 字节型 | byte | 1 | -128~127 | 0 |
| 短整型 | short | 2 | -2·15~（2·15）-1 | 0 |
| 整型 | int | 4 | -2·31~（2·31）-1 | 0 |
| 长整型 | long | 8 | -2·63~（2·63）-1 | 0 |
| 字符型 | char | 2 | 0~（2·16）-1 | ‘\u0000’ |
| 单精度浮点型 | float | 4 | 1.4013E-45~3.4028E+38 | 0.0F |
| 双精度浮点型 | double | 8 | 4.9E-324~1.7977E+308 | 0.0D |
强制类型转换 long g=1000L int
i=(int)g 布尔类型不能转换成其他任何数据类型
二、关键字
三、数组
int x[];
int[] x=new int[3]
int[] x=new int[]{3,4,5}
int[] x={1,2,3,4}
多维数组 int[] x=new int[3][4];
四、面向对象
构造方法： Duck d=new
Duck(); 如果存在多参数的时候 默认会覆盖无参的，如果需要则必须写出来（默认开发的话保留初始化构造方法）
方法重载：方法名相同，参数有多个，参数顺序不同函数不同
方法重写：
1.发生方法重写的两个方法返回值，方法名，参数列表必须完全一致（子类重写父类的方法）
2.子类抛出的异常不能超过父类相对应方法抛出的异常(子类异常不能大于父类异常)
3.子类的方法访问级别不能低于父类相应方法的访问级别（子类访问级别不能低于父类访问级别）
匿名对象：new Duck().func(); 特点只能使用一次，只使用一次对象，即可这样使用，直接在堆内存中开辟空间，会被GC回收，不易多次使用，以免产生垃圾
String类两种赋值:
String s1=new String("abc"); //会创建2个字符串对象，一个是堆内存new
String("abc"),一个是创建字符串常量池对象
String s2="abc" //这里先去字符串常量池查找有没有“abc”,如果没有就在字符串常量池创建，并指向常量池字符串
String类编译期和运行期：
1
String a="a1"; 编译期就确定了值
String a1="a"+1; 编译期确定了值 //a==a1
true
2
String b="b1"; 编译期就确定了值
int bb=1; 编译期确定了值
String b1="b"+bb; 编译期无法确定值，bb是个变量，只有到运行期才能确定具体值 //b==b1
flase
3
String c="c1"; 编译期就确定了值
final int cc=1; 编译期确定了值
String c1="c"+cc; 编译期CC已被常量1替换，所以确定具体值 //c==c1
true
4
String d="d1"; 编译期就确定了值
final int dd=getDD(); 编译期无法确定
String d1="d"+dd; 编译期dd函数还没有被指向，必须到运行期dd才能被函数的返回值1替换成常量，所以确定具体值 //d==d1
true
Static关键字（静态数据不是属于对象，属于类）
static修饰的变量 存放在内存方法区，在内存里面只创建一份数据
static方法里面不能调用this、super类对象关键字
static只能修饰内部类
五、对象数组
class ObjArray
{
public static void main(String[] args)
{
ManageMonkey mm=new ManageMonkey();
mm.add(new Monkey("张三",'m'));
mm.add(new Monkey("李四",'w'));
mm.add(new Monkey("王五",'m'));
mm.add(new Monkey("cc",'m'));
mm.list();
System.out.println("##############################");
/*Monkey m=mm.find("张三");
m.print();
System.out.println("##############################");
mm.edit("李四",'女');
mm.list();
System.out.println("##############################");*/
mm.del("cc");
mm.list();
}
}
//管理猴子类
class ManageMonkey
{
private Monkey[] mokenys=new Monkey[4];
private int count=0; //当前对象个数
public ManageMonkey(){}
//添加对象
public void add(Monkey m){
if(count<mokenys.length){
mokenys[count]=m;
count++;
}else{
System.out.println("对象数组已满");
}
}
//删除对象
public void del(String name){
for(int i=0;i<count;i++){
if(mokenys[i].getName().equals(name)){
for(int j=i;j<count-1;j++){
mokenys[j]=mokenys[j+1];
}
}
mokenys[count-1]=null;
count--;
}
}
//查找对象
public Monkey find(String name){
for(int i=0;i<count;i++){
if(mokenys[i].getName().equals(name)){
return mokenys[i];
}
}
return null;
}
//修改对象
public void edit(String name,char sex){
Monkey m=find(name);
m.setSex(sex);
}
//打印数组对象
public void list(){
for(int i=0;i<count;i++){
mokenys[i].print();
}
}
}
//猴子对象
class Monkey
{
private String name;
private char sex;
public Monkey(){}
public Monkey(String name,char sex){
this.name=name;
this.sex=sex;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setSex(char sex){
this.sex=sex;
}
public char getSex(){
return sex;
}
public void print(){
System.out.println("name="+name+",sex="+sex);
}
}
六、foreach使用（只适合遍历，不适合android这样对内存要求比较高的开发，因为他会不断的产生内存对象）
可变参数用法（参数列表里面只能有一个可变参数，并且可变参数只能在最后一个）
method (int num,String... names){
for(String name:names){
System.out.print(name);
}
}
调用的
method("123","cvb","qw","fgh");
七、代码块
1、普通代码块：在方法中使用，作用域只在最近的{}内
2、构造代码块：在构造对象时调用，在类中的代码块，先于构造方法执行
3、静态代码块：在构造代码块前加上static,在类加载时只执行一次
八、单例设计模式（面试）[构造方法私有化，静态方法获取对象]
饿汉式
class Singleton
{
private static Singleton s=new Singleton();
private Singleton(){}
public static Singleton getInstans(){
return s;
}
public void print(){
xxxxx
}
}
懒汉式
class Singleton
{
private static Singleton s=null;
private Singleton(){}
public static Singleton getInstans(){
if(s==null){
s=new Singleton();
}
return s;
}
public void print(){
xxxxx
}
}
八、final关键字
1.final声明一个类，该类不能被继承
2.final声明一个方法，该方法不能被子类重写
3.final声明一个常量，如果数据类型是 类类型，那么地址不能变
九、抽象类（abstract）
抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
非抽象类继承抽象类的时候，必须实现抽象类里面的所有抽象方法
抽象类可以有方法和属性
抽象类不能被实例化
抽象类不能被final
十、接口
interface hit{
public void cry()
}
class god implements his{
}
1.接口可以继承多个
2.一个类可以实现多个接口
3.抽象类实现接口可以不实现接口里面的方法
4.接口中所有的方法全部是public
5.接口中所有的属性都是常量而且是静态的
十一、多态
向上转型：将子类实例转为父类实例 格式：父类 父类对象=子类实例 (new 谁就调用谁的方法)
向下转型：子类对象转变成父类 格式:子类 子类对象=（子类）父类实例
多态性:
1.方法的重载与重写就是方法的多态性表现
2.多个子类就是父类中的多种形态
3.父类引用可以指向子类对象，自动转换
4.子类对象向父类引用需要强制转换（注意：类型不对会报异常）
5.在实际开发中尽量使用父类引用（更利于扩展）
十二、内部类
12.1 成员内部类
Outer out=new Outer(); //产生外部类
Outer.Inner in=null; //声明内部类对象
in=out.new Inner();//创建内部类实例
12.2 方法内部类
//方法内部类只能在该类方法里面实例化（作用域决定）
func (){
class Inner{
funcInner(){}
}
Inner i=new Inner();
i.funcInner();
}
//方法内部类对象不能使用该内部类所在方法的非final局部变量
//局部变量的属性生命周期没有内部类的生命周期长
func (){
int x=10; //Q1 final int x=10;
class Inner{
funcInner(){
System.out.println("x="+x); //Q1 此时这里的x 必须定义为final
}
}
Inner i=new Inner();
i.funcInner();
}
12.3静态内部类
//静态内部类只能访问静态属性
外部实例化 静态内部类 Outet.Inner oi=new Outet.Inner(); //一个静态内部类 相当于外部类
12.4 匿名内部类
原则：
1.不能有构造方法，只能有一个实例
2.不能定义任何静态成员、静态方法
3.不能是public\protece\private\static
4.一定是在new的后面，用其隐含实现一个接口或实现一个类
5.匿名内部类为局部的，所以局部内部类的所有显示都对齐生效
12.4-1继承式匿名内部类
main:
Dog d=new Dog(){
public void say(){}
};
d.say();
12.4-2接口式匿名内部类
interface Child{
public void say();
}
main:
Child c=new Child(){
public void say();
};
c.say();
12.4-3参数式匿名内部类
interface Child{
public void say();
}
main:
func(new Child(){
public void say(){xxxxxx}
});
public static void func(Child c){
c.say();
}
十三、链表
class LinkList //链表类demo
{
public static void main(String[] args)
{
NodeMange nm=new NodeMange();
nm.addNode("节点1");
nm.addNode("节点2");
nm.addNode("节点3");
nm.addNode("节点4");
nm.addNode("节点5");
nm.printNode();
nm.delNode("节点3");
nm.printNode();
}
}
//链表节点管理
class NodeMange{
private Node root;//根节点
//添加节点
public void addNode(String name){
//判断根节点是否为空
if(root==null){
root=new Node(name);
}else{
root.add(name);
}
}
//删除节点
public void delNode(String name){
if(root!=null){
if(root.name.equals(name)){
root=root.next;
}else{
root.del(name);
}
}
}
//打印节点
public void printNode(){
if(root!=null){
System.out.print(root.name);
root.print();
System.out.println();
}
}
//定义节点内部类
class Node{
//节点名称
private String name;
//表示下一个节点对象
private Node next;//把自己的类型作为属性类型（单向链表）
public Node(String name){
this.name=name;
}
//添加节点
public void add(String name){
if(this.next==null){
this.next=new Node(name);
}else{
this.next.add(name);
}
}
//删除节点
public void del(String name){
if(this.next!=null){
if(this.next.name.equals(name)){
this.next=this.next.next;
}else{
this.next.del(name);
}
}
}
//输出节点
public void print(){
if(this.next!=null){
System.out.print("-->"+this.next.name);
this.next.print();
}
}
}
}
十四、数据类型包装类
1.基本数据类型包装类
Number:Integer、Short、Long、Double、 Float 、Byte都是Number的子类表示是一个数字
Object:Character、Boolean都是Object的直接子类
| 基本数据类型 | 包装类 |
| Boolean | Boolean |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
Integert x=10 (当直接赋值是，当值为1个字节内的数时，将使用同一个对象)【-128~127】
十五、异常处理
1.try{
//有可能发生异常的代码段
}catch(异常类型对象a){
//异常处理的操作
}catch(异常类型对象b){
//异常处理的操作
}
父类异常应该写在最下面，优先匹配子类异常
finally 即使return了 finally也会先执行了 在执行return
2.throw与throws
public class ExceptionDemo2 {
public static void main(String[] args) {
try{
add();
}catch(Exception ex){
ex.printStackTrace();
}
}
public static int add()throws Exception{
Scanner input =new Scanner(System.in);
try{
System.out.println("请输入第一个数：");
int num1=input.nextInt();
System.out.println("请输入第二个数：");
int num2=input.nextInt();
return num1+num2;
}catch(Exception ex){
throw new Exception("加法运算异常");
}finally{
System.out.println("运算结束");
}
}
}
十六、StringBuffer类
对于字符串管理比String类更高效，StringBuffer[适合多线程]和StringBuilder[适合单线程]
十七、国际化（locale类）
可以在IE浏览器属性语言里面找到对应的语言编号
Locale local=new Locale("zh","CN");
Locale local2=Locale.US; //代码常量
Locale local3=Locale.getDefault(); //根据系统默认语言环境
定义语言包 后缀 *.properties
info_zh_CN.properties
username=xxxxx
调用
ResourceBundle res=ResourceBundle.getBundle("com.vine.i18n.info",locale);
String username=res.getString("username");
处理动态文本
username=xxxxx {0}//占位符 xxx.[admin]谁登陆就显示谁
MessageFormat.format(username,'admin');
十八、常用工具类
Math数学类，Random随机数类，Array数组类，Date日期类，Calendar日历类，DataFormat和SimpleDateFormat日期格式化类
十九、对象比较器
自定义对象如果排序，必须实现Comparable接口compareTo方法
Class Persion implements Comparable<Person>
public int compareTo(Person o){
if(o==null){
throw new NullpotionException();
}
return 0;
if(this.age>o.age){
retuen 1;
}else if(this.age<o.age){
return -1
}
}
或者 自定义比较器类
Class PersionComparable implements Comparable<Person>{}
Arrays.sort(Person,PersionComparable );
二十、对象的克隆
在Object对象中存在一个clone()方法，如果某个类的对象想要被克隆，则对象所在的类必须实现Cloneable接口，此接口没有定义任何方法，是一个标记接口
二十一、IO
1.File类 目录遍历和文件遍历
2.字节输出流 outputStream os=new FileOutputStream类
//文件写入
3.字节输入流 InputStream in = new FileInputStream("g:\\1.txt"); //文件读取
4.字符输出流
public static void write1() {
File f = new File("g:\\1.txt");
try {
//构造一个字符输出流对象
Writer w = new FileWriter(f,true);
String info="好好学习,天天向上";
w.write(info);
w.close();
} catch (IOException e) {
e.printStackTrace();
}
}
5字符输入流 （这样防止乱码，文本文件适合）
public static void reader1() {
File f = new File("g:\\1.txt");
try {
Reader in = new FileReader(f);
char[] cs = new char[20];
int len = -1;
StringBuffer sb = new StringBuffer();
while ((len = in.read(cs)) != -1) {
sb.append(new String(cs, 0, len));
}
in.close();
System.out.println(sb);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
6.对象序列化（对象必须实现seralizable接口才能被序列化）
7.字节数组流
二十二、集合框架
二十三、线程和进程
线程是进程的进一步划分，一个程序可以看做是一个进程，执行过程可以可以划分多个线程，线程之间可以互相切换
多线程的实现方式
1.继承Thread类 ------myThread.start()启动线程
2.实现Runnable接口run方法 //更推荐使用runnable方法启动线程，自定义类的话继承的话受限于Threadf单继承
MyRunnabe mr=new MyRunnabe();
Thread t=new Thread(mr);
线程同步机制
object obj=new Object();
方式一 ：synchronized（obj）{
同步代码块
}
方式二：public function synchronized run(){
同步代码块
}
二十四、反射
Java的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object
二十五、內省机制
内省(IntroSpector)是Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性，这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，通过这些 API 可以使你不需要了解这个规则（但你最好还是要搞清楚），这些 API 存放于包 java.beans 中,一般的做法是通过类 Introspector
的 getBeanInfo方法 来获取某个对象的 BeanInfo 信息,然后通过 BeanInfo 来获取属性的描述器(PropertyDescriptor),通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法,然后我们就可以通过反射机制来调用这些方法。
JavaBean 必须含有get\set方法
相关API：IntroSpector 、BeanInfo、Properties（负责读取*.properties文件）
二十六、泛型
1、泛型
2、通配符
public void method(Person<?> p){
P.getAge(); 只能调用，不能修改
}
上限： public class Person<T extends Number>{} //必须是Number的子类
下限:public function method(Person<? super String> p){} //必须是string的父类
3、泛型接口
public interface Test<T>{
public void eat(T e);
}
4、泛型方法
public static <T>T[] func(T[] array,int i,int t){ //泛型方法2个数组换位置
T temp=array[i];
array[i]=array[t];
array[t]=temp;
return array;
}
5、泛型嵌套使用
Set<Entry<Integer,String>> entrys=map.entryset();
二十七、枚举
1.Enum类与enum关键字
使用enum关键字，实际就是定义了一个Enum类的子类
class enum EnumController{
ON,OFF
}
EnumController econ=EnumController.ON;
2.集合对枚举的支持
EnumSet\Enummap
3.带构造方法的枚举(不能在外面定义对象)
class enum EnumGril{
Gril1,Gril2;//这个一定要最前面
private String name;
private EnumController(){}
}
main:
EnumGril egs=EnumGril.Gril1;
这样调用的都是无参的的构造方法
class enum EnumGril{
Gril1("xuchen"),Gril2("abc");//这样调用的就是有参的构造方法
private String name;
private EnumController(){}
private EnumController(String name){}
}
main:
EnumGril egs=EnumGril.Gril1;
这样调用的都是有参的构造方法
4.让枚举实现接口 //不能继承类，因为enum关键字已经隐式继承了Enum类
interface Info{
public String getColor();
}
class enum EnumColor implemetns Info{
Red{
public String getColor(){ return "red"}
},Blue{
public String getColor(){ return "blue"}
},Green{
public String getColor(){ return "green"}
}
}
5.在枚举中定义抽象方法
class enum EnumController {
ON{
public EnumController downAction(){
return OFF;
};
},OFF{
public EnumController downAction(){
return ON;
};
}
public abstract void downAction();
}
二十八、XML解析
使用DOM解析XML
SAX解析XML
GUI插件是VE插件
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 