JAVA自学笔记

1、Override函数的复写

复写（override):也称覆盖/重写
子类调用父类的函数，但要修改后才使用，这个过程就叫复写
使用条件：
1.在具有继承关系的两个类中
2.子类和父类的两个函数的函数名，参数列表，返回值类型完全一致


class Person{
         intname;
         intadress;
         voidintroduce(){
                   System.out.println("我的名字是"+name+"我的地址是"+adress);
         }
}


clsss Student extends Person{
         intage;
         voidintroduce(){
                   System.out.println("我的名字是"+name+"我的地址是"+adress);
                   System.out.println("我的年龄是"+name);//子类中修改了继承来的函数，即为复写
         }
}




下面使用super关键字来消除重复代码（System.out.println("我的名字是"+name+"我的地址是"+adress);）
clsss Student extends Person{
         intage;
         voidintroduce(){
                   super.introduce();
                   System.out.println("我的年龄是"+name);//子类中修改了继承来的函数，即为复写
         }
}

 

2、Static关键字

静态成员变量
Static int i;


不仅可以像普通成员变量一样使用“对象名.变量名”调用
还可以使用“类名.变量名”调用（无需申明对象），这样使用时，如果该变量值一旦改变，该类的所有对象的该变量一起改变
同理，如果该类的对象一的该成员变量值改变（使用 “对象名.变量名” = ?  改变），该类的其他所有对象的该成员变量的值也一起改变


解释：静态成员变量是类的成员变量，而不是对象的成员变量，由该类的所有对象共用（静态函数和静态成员一样）


在静态函数中不能使用非静态变量（不能使用this）




class Person{
         staticint i;
}


clsss Test{
         publicstatic void main(String arg []){
                   Personp1 = new Person();
                   Personp2 = new Person();


                   Person.i= 10;
                   System.out.println(p1.i);
                   System.out.println(p2.i);
                   //打印出的p1,p2的值都是10


                   Person1.i= 20;
                   System.out.println(p1.i);
                   System.out.println(p2.i);
                   //打印出的p1,p2的值都是20
         }
}




静态代码块
class Person{
         static{
                   System.out.println("静态代码快")
         }
}
每次使用这个类都会执行一次静态代码块（类似于构造函数）

 

3、Super调用父类函数

Super关键字用于调用父类中的构造函数


class People{
         intage;
         intsex;
         People(intage,int sex){
                   this.age= age;
                   this.sex= sex;
         }
}


class Student extends People{
         intname;
         Student(intage,int sex,int name){
                   super(age,sex);//此时调用父类People中的有参购造函数People(intage,int sex)
                   //如果不加这一句，编译时会自动加上"super();"来调用父类的无参构造函数（默认构造函数）
                   this.grade= grade;
}


和this一样，使用super关键字时必须是函数中的第一行，否则编译会报错
子类无法继承父类的构造函数，所以使用super来调用父类的构造函数，以便减少重复代码


同样的super也可以调用父类的成员函数


super（有参或无参）;//调用父类的构造函数
super.函数名（）;//调用父类的成员函数

 

 

4、this关键字

this 翻译成“我”
this指调用当前类或当前函数的那个对象


例
class Person{
         Stringname;


         voidtalk(String name){
                   1. System.out.println("my name is:" +　this.name);
                       此时打印出的将是Person类中定义的name变量的值
                      （this 指调用该函数的对象（该对象使用Person类）而不是传入该函数的值）
                  
                   2. System.out.println("my name is:" +　name);
                       此时打印出的将是函数talk传入的的name变量的值
         }
}


this.成员变量
this.函数名（）//调用本类的成员函数
this()//调用本类的构造函数

5、对象的转型

向上转型：
将子类的对象赋值给父类的引用
Student s = new Student();
Person p = s;
//等效写法 Person p = new Student();
(张三是个学生-->张三是个人)


此时p只能使用Person里有的变量，函数





向下转型：
将父类的对象赋值给子类的引用
Student s1 = new Student();
Person p = s1;
Student s2 = (Student)p;//强制类型转换


必须先将对象向上转型，才能向下转型回原类型（看起来多此一举，以后会用到的）
例：一块方便面面饼，厂家先加上包装袋（向上），买家又拆开包装袋（向下）后才看到面饼。

6、继承

JAVA只支持单继承（只能继承一个父类，C++可以继承多个父类）


class 子类 extentds 父类{
}

7、数组

 class Test{
public static void main(String arg []){

int arr [] = {1,2,3,4,5};//等效于 int [] arr = {1,2,3,4,5}
//数组的静态定义方法

int arr [] = new int [10];//声明了一个长度为10的数组，初始值为0
//数组的动态声明法

int arr[][] = {{1,2,3},{4,5,6},{7,8,9}};
//二维数组
}
}

8、equals函数

equals是object类中的函数,object是java中所有类的父类，所以任何地方都可以直接使用equals()方法


equals和“==”的对比
class test{
public static void main(String[] args){
User u1 = new User();
User u2 = new User();
User u3 = u1;

boolean b1 = u1 == u2;
boolean b2 = u1 == u3;

System.out.println(b1);//打印出“false”
System.out.println(b2);//打印出“true”
//双等号“=="用于比较两个引用是否指向同一块堆内存

boolean c1 = u1.equals(u2);
System.out.println(c1);//打印出“false”
//equal用于判断两个对象的内容是否相同（类型相同+值相同）,但是这里为什么还是true呢
//因为object中的equals是比较抽象的，原则上要复写该方法才使用，不然效果与“==”就没区别了
}
}




小结：
双等号“=="用于比较两个引用是否指向同一块堆内存
equal用于判断两个对象的内容是否相同（类型相同+值相同）

9、hashCode与toString()

hashCode()与toString()和equals()一样，也继承与object类,所以所有的类都能直接用hashCode（）方法
hashCode（）没有参数，返回值是一个整数，一般也是复写后再使用




    Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），
通过散列算法，变换成固定长度的输出，该输出就是散列值。简单的说就是一种将任意长度的消息压缩到某一固定长度
的消息摘要的函数。






    ToString(），把一个任意对象转换成一个字符串
   

10、抽象类

用于适应开发过程中客户不断变化的需求，可以方便灵活的随机应变


思路模型：如果有多个类似的类
那么先定义一个模糊的父类
然后再分别定义这些类继承模糊父类，在这些类用super，this等关键字使每个类都有每个类的特色
使用抽象类的优点：减少重复代码，提高代码的可维护性，可拓展性


抽象函数也是类似（先在父类中定义个函数，但是什么功能都不写）




实际使用：


abstract class 父类名{
abstract 函数名（）；
}


当使用了abstract关键字时，如果某个子类没有复写父类中的这个抽象函数，则会编译报错

11、接口

定义了接口就是定义了调用对象的标准




接口的基本语法（一）：(inerface)
1.使用interface定义
2.接口当中的方法都是抽象方法
3.接口当中的方法都是public权限(不写public也默认是pubilc权限)


接口的基本语法（二）
1.实现接口使用implements关键字
2.一个类可以实现（继承）多个接口  class Phone implements USB,WiFi{ }// 一个类（Phone）实现（继承）多个接口（USB，WiFi）
3.一个接口可以继承多个接口  interface C extends A,B{ }//一个接口（A）继承多个接口（B，C）



简单静态工厂方法模式

12、类集框架

集合（set）
集合的对象不按特定的方式排序，并且没有重复对象
列表（list)
集合中对象按照索引位置排序，可以有重复的对象
映射（Map）
集合的每一个元素包含一个键对象和一个值对象，键不可以重复，值可以重复




先举个简单例子：
使用ArrayList，一个无长度限制的列表结构（动态数组）
import java.util.List;//导入List接口
import java.util.ArrayList;//导入ArrayList实现类


public class test{
public static void main(String args []){
ArrayList<String> arrayList = new ArrayList<String>();
//创建一个只能存String类型（填类名）对象（数据）的ArrayList
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");//添加数据，从第0个位置开始顺序添加
arrayList.remove(1);//移除1号位置的对象b;
String a = arrayList.get(1);//得到一号位置的对象c;
System.out.println(a);
int len = arrayList.size();//得到长度为2
System.out.println(len);
}

}




“<--”表示继承关系
Iterator(迭代器接口)<--Collection（集合接口）<--Set（Set接口） <--HashSet（HashSet实现类）
                                            <--List(List接口）<--ArrayList(ArrayList实现类)








类集框架有两个顶级接口Iterator 和 Collection
Cllection的方法 add（），isEmpty()，remove(),get(),size()
Iterator的方法 hasNext()  next()






一、Collection（集合）接口配合迭代器的使用


import java.util.Set;//导入Set接口
import java.util.HashSet;//导入实现类
import java.util.Iterator;//导入迭代器接口


public class test{
public static void main(String args []){
//HashSet<String> hashSet = new HashSet<String>();
//Set<String> set = hashSet;//将具体的实现类向上转型为Set接口类型（我猜是为了不用复写一系列方法）
Set<String> set = new HashSet<String>();//前面两句等效于这句

set.add("a");
set.add("b");
set.add("c");
set.add("c");//重复元素会被忽略掉，没有增加元素个数，这句代码相当于作废
set.add("d");
int len = set.size();//获取集合中元素个数，len = 4
/*************
set.remove("a");//移除a元素
set.clear();//清除set中的所有元素
boolean b = set.isEmpty();//判空，此时b的值为true
*************/
Iterator<String> it  = set.iterator();//勿忘声明对象为String类型
//调用Set对象的itearator()方法,会生成一个迭代器对象
//boolean b1 = it.hasnext();//判段it对象后面还有没有对象,有则返回true
while(it.hasNext()){
String s = it.next();
System.out.println(s);
//使用迭代器把所有元素都取出来（注：无序）
}

}
}




二、Map与HashMap的使用方法


import java.util.Map;
import java.util.HashMap;


public class test{
public static void main(String args []){
HashMap<String,String> hashMap = new HashMap<String,String>();//创建键和值都是String类型的对象
Map<String,String> map =hashMap;//向上转型

map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("3","e");//键一样，后面的值会覆盖前面的值
map.put("4","d");
map.put("5","e");//加入5个键值对

int i = map.size()//获取长度
String s = map.get("3");//根据键来取值

}
}

13、匿名内部类

内部类：
class A{
int i;
class B{
int j;
int fun(){
int result = i + j;
//内部类可以随意使用外部类的变量，但B并不拥有i,不等于继承。
return result;
}
}
}


class test{
public static void main(String args[]){
A a = new A();
A.B b =a.new B();
//要生成一个内部类的对象必须先生成一个外部类的对象
a.i = 3;  b.j =1;
   System.out.println(b.fun());
}
}






匿名内部类：
interface A{
public void DoSomething();
}


class B{
public void fun(A a){
System.out.println("B类的fun函数");
a.DoSomething();
}
}


class test{
public static void main(String args[]){
B b = new B();
b.fun(  new A(){
public void DoSomething(){
System.out.println("匿名内部类");
}
//A是个接口，不能用new生成一个对象，new A()说明要实现A接口，而不是实现的A接口（没有对象）
/*
后面的{
public void DoSomething(){
System.out.println("匿名内部类");
}
这个类就是A接口的实现类，该类没有名字
这个类就叫匿名内部类
*/

}
);
}
}

14、软件包

软件包（文件夹）
一个类的全名应该是“包名.类名”


Java当中的访问权限




1.public:公共权限（可修饰类/函数/变量）
如果一个类被定义为公有权限，那么这个类的名字必须与源文件的名字一致。
跨宝使用类时应写上类的全名（包名+全名）
packge 1;
public class Person{
public string name;
}


packge 2;
public class Test{
1.Person p = null;//在2包的Test类中生成一个1包的Person类的对象
}





2.private：私有权限（只能修饰函数和变量，一般不修饰类），
   private变量/函数只能在当前类中使用



3.default:包级别访问权限（可修饰类/函数/变量）
不写public/private/protected修饰符时，就默认是default。同包中可自由使用




4.protected:受保护权限（首先拥有default的权限一样，但是protected不能修饰类（可修饰成员函数/变量），
protected可以跨包使用（前提是跨包的这个类必须是protected所在类的子类））


权限：public>protected>default>private




包的导入
packge 3;
import 1.*; //将1包中的所有类都导入
public class My{
Person p = new Person();
//使用1包中的类时不用再写包名+类名，直接写类名即可。
}

15、异常机制

异常：（是一个对象，由虚拟机生成）中断了指令流的一种事件。运行时产生，编译能通过。




try{
此处写可能出现异常的代码（多行）
当执行到某行出现异常时就跳转到catch语句
如果都不出现异常，就不执行catch语句
}


catch{
写对异常处理的代码
}


（以下可写可不写）
finally{
写清理资源的代码
无论是否出现异常都执行
}


以上语句无论如何执行以后的语句都会执行




异常类
父类：Exception(直接用其定义对象必须捕捉（使用try case 抛出））
或声明（即声明我（函数名 + throws + 异常类的类名（即Exception））可能出现异常，但我可以不处理，谁调用我谁再处理）)
子类1：RunTimeException
子类2：除1外的其他子类（直接用其定义对象必须使用try case 抛出）




一.RuntimeException(运行时异常)的使用：
class User{
private int age;

public void setAge(int age){
if(age<0){
RuntimeException e = new RuntimeException("年龄不能为负数");//定义一个异常对象
throw e;//抛出异常（在控制台打印），此时整个程序结束
}
this.age = age;
}
}


class UserText{
public static void main(String args[]){
User user = new User();
user.setAge(-20);
}

}




二.Exception的使用：
class User{
private int age;

public void setAge(int age) {
try{
if(age<0){
Exception e = new Exception("年龄不能为负数");
throw e;//定义异常并把它抛出
}

}
catch(Exception p){//捕获之前抛出的异常

System.out.println(p);
}
this.age = age;
}
}




class UserText{
public static void main(String args[]){
User user = new User();
user.setAge(-20);
}
}






三.throws声明异常：
class User{
private int age;

public void setAge(int age) throws Exception{
//使用throws声明有函数可能产生异常，但是我先不处理（先抛出，不处理），谁调用我谁再处理
if(age<0){
Exception e = new Exception("年龄不能为负数");
throw e;
}
this.age = age;
}
}


class UserText{
public static void main(String args[]){
User user = new User();
try{
user.setAge(-20);
}
catch(Exception p){
System.out.println(p);
}
}
}


16、IO大文件及字符流

大文件读写操作的要点
用循环控制，每次循环处理大文件的一小部分数据（考虑到内存，buffer数组不能开得太大）


import java.io.*;
class test{
public static void main(String arg[]){

FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("f:/java/from.txt");
fos = new FileOutputStream("f:/java/to.txt");
//生成输入输出流对象，相当于往两个文件中分别插了一个水管
byte [] buffer = new byte[1024];//每次处理1024个字节。1kb
while(true){
int temp = fis.read(buffer,0,buffer.length);
if(temp == -1){
break;//temp的返回值为-1，说明文件内容已被读取完毕
}
fos.write(buffer,0,temp);
}
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
fis.close();
fos.close();
//关闭IO流，把两个水管都拔出来
}
catch(Exception e){
System.out.println(e);
}
}
}
}






字符流：
字节流-->字符流
FileInputStream fis = null;       --> FileReader fis;
FileOutputStream fos = null;      --> FileReader fos;
byte [] buffer = new byte[1024];  --> char[]buffer = new char[1024];
其余的字节流和字符流一样

17、IO节点流及处理流

节点流：一根管道，管道中流淌的是真正的数据
处理流：对节点流管道中的数据进行处理,装饰（装饰者 butterreader）


import java.io.*;
public class test{
public static void  main(String args[]){
FileReader fileReader = null;
BufferedReader bufferedReader = null;
try{
fileReader = new FileReader("f:/JAVA/data.txt");
bufferedReader = new BufferedReader(fileReader);
//用bufferedReader来修饰fileReader（buffferReader也可以修饰其他各种类型的流），使每次读入一行数据，
String line = null;
while(true){
line = bufferedReader.readLine();
if(line == null){
//当读完最后一行后，bufferedReader.readLine()返回值为null
break;
}
System.out.println(line);
}
}
catch(Exception e){
System.out.println(e);
}
}
}


另外视频“[Java4Android]34_Java当中的IO（三）”中有个很经典的使用修饰类的设计模式

18、IO字节流

输入流是一个对象，输出流也是一个对象


InputStream/OutputStream是所有的字节流的父类（是抽象类，不能直接生成对象）
子类举例:
FileInputStream/FileInputString(读写文件的子类)


InputStream：（从文件读到JAVA程序）
int read(byte[]b,int off,int len)
byte[]b:储存数据的比特类型数组的名称
int off:offset 偏移量,表示从数组的第几位开始存放数据(即让数组的前几位空着)
int len:表示一次最多读多少个数据（往往 用len-off防止数组越界）


OutputStream:
void write(byte[]b,int off,int len)






//使用IO流的第一步骤，导入类
import java.io.*;
class test{
public static void main(String arg[]){

//一、读取该目录下文件的数据以比特类型（asc码）存到数组buffer中
// 声明输入流引用
FileInputStream fis = null;
try{
//生成输入流对象
fis = new FileInputStream("f:/java/from.txt");
//生成一个数组用于储存fis的数据
byte [] buffer = new byte[100];
//调用输入流的read方法，读取数据
//fis.read(buffer,5,buffer.length-5);
//从数组buffer的第六个位置开始存放fis
//（fis中的数据是从头开始存放，直到把buffer数组填满为止）的数据（buffer剩余95个可用位置），
//放不下100个数据（第三个参数表示最多读取多少个数据），故length-5

//read函数的返回值为本次读取的字节数，下面代码为获取它的返回值，
//便于后面把这些数据写入另一个文件（读多长久写多长）,可以和上面那行代码合并
int temp = fis.read(buffer,5,buffer.length-5);


String s = new String(buffer);//把asc码还原为字符串
s = s.trim();//小技巧，去掉字符串首尾的空格部分
System.out.println(s);

//将buffer数组的数据输出到to.txt文件中
FileOutputStream fos = null;
fos = new FileOutputStream("f:/java/to.txt");
fos.write(buffer,5,temp);//若偏移量为0，则输出的前五个字符为空格

}
catch(Exception e){
System.out.println(e);
}
}
}

19、线程的常用函数及实现二

实现线程的第二种方法:
（实际开发中能用接口就不用类，类只能单继承）
使用接口Runnable实现类
例：
class RunnableImpl implements Runnable{
public void run(){
for(int i = 0; i < 100; i++){
System.out.println("RunnableImpl-->"+i);
}
} 
}


class test{
public static void main(String[] args){
RunnableImpl ri = new RunnableImpl();
//生成一个Runnable接口实现类的对象
Thread t = new Thread(ri);
//将ri作为参数传给Thread类的构造函数，来创建一个Thread对象，以便于使用Thread的方法
t.start();
}
}




线程的简单控制方法
Thread.sleep()         传入一个整数a，使线程休眠a毫秒，醒后又进入就绪状态，开始和其他线程抢CPU
Thread.yield()         线程自动让出CPU，但不退出，一让出又立马和其它线程抢CPU，可能又是自己立马抢到
Thread.getPriority()   获取线程的优先级，（优先级为数字1到10）
Thread.setPriority()   设置线程优先级，优先级越大抢到CPU的概率越大（注：只是概率）

20、线程简介及实现一

多进程：操作系统中同时运行多个任务（程序）（CPU在各进程中快速切换工作，看起来各进程就像在同步进行）
多线程：同一应用程序中有多个顺序流同时执行（前台在看电影，后台在下载文件）
线程就是进程中的一个程序执行流程
android每启动一个软件就启动一个进程






JAVA创建线程的方法
方式一：
    定义一个线程类，它继承Thread并重写其中的方法run(),方法run(）成为线程体
    由于Java只支持单继承，这种方法继承的类不能再继承其它类。


例：
class FirstThread extends Thread{
    public void run(){
for(int i=0; i<50; i++)
{
System.out.println("FirstThread-->"+i);
}
}
}


class test{
public static void main(String args[]){
FirstThread ft = new FirstThread();
ft.start();//启动线程，使线程进入就绪状态与开始其它线程抢CPU，并立即执行后面的代码
//如果用ft.run()则执行完该线程才执行后面的代码,这样就还是单线程执行，没有实现多线程
for(int j=0; j<50; j++)
{
System.out.println("mainThread-->"+j);
}
}
}
//这段代码中有三个线程，主函数线程，ft线程，垃圾回收线程（不管）
//主函数线程和ft线程互相抢CPU，同优先级
//所以一会打印出"FirstThread-->"+i，一会打印出"mainThread-->"+j，i和j循环交替运行，无规律性

21、线程数据安全及同步方法

Thread.cureentThread()//获取当前正在运行的进程
System.out.println( Thread.cureentThread().getName() );
Thread.setName();//为线程设置名字 






线程同步错误
多线程使用同一份数据时容易出现错误
解决方案：使用同步代码块（同步锁）-->即某个线程执行某块代码时，其他线程就算抢到了CPU也无法执行这块代码
synchronized关键字




例：
class MyThread implements Runnable{
int i = 100;
public void run(){
while(true){
synchronized (this){
//该大括号内代码为一个代码块，每次只有拿着this这把锁的线程才能访问这块代码
//例如A线程正在执行这块代码，突然CPU被B抢走了，B就从synchronized这一行开始执行，
//但是拿this这把钥匙还在A手上，B无法继续执行，
//等A又抢到CPU继续执行完这块代码时会放回钥匙，A，B再公平竞争
System.out.println(Thread.currentThread().getName()+i);
i--;
Thread.yield();
if(i < 0){
break;
}
}
}
}
}


class test{
public static void main(String[] args){
MyThread mt = new MyThread();
Thread A = new Thread(mt);
Thread B = new Thread(mt);
//生成两个Thread对象，但是这两个对象共用同一个线程体

A.setName("线程A");
B.setName("线程B");

A.start();
B.start();
}
}

22、线程同步方法进阶

//*********************************************************************//  
class Service{  
    public void fun1{  
      synchronized(this){  
        tyr{  
            Thread.sleep(3000);  
        }  
        catch(Exception e)  
        {  
            System.out.println(e);  
        }  
        System.out.println("fun1");  
      }  
    }  
      
    public void fun2{  
         synchronized(this){  
            System.out.println("fun2");  
         }  
    }  
}  
//**********************************MyThread1***********************************//  
class MyThread1 impelements Runnable{  
    private Service service;  
    public MyThread1(Service service){  
        this.service=service;  
    }  
    public void run(){  
        service.fun1;  
    }   
}  
//**********************************MyThread2***********************************//  
class MyThread2 impelements Runnable{  
    private Service service;  
    public MyThread2(Service service){  
        this.service=service;  
    }  
    public void run(){  
        service.fun2;  
    }   
}  
//*********************************************************************//  
class Test{  
    public static void main(String args[]){  
        Service service=new Service();  
        Thread t1=new Thread(new MyThread1(service));  
        Thread t2=new Thread(new MyThread2(service));  
        t1.start();  
        t2.start();  
    }  
}  


    t1.start();启动线程1，线程1执行的是fun1(),fun1() 进入  synchronized(this) 同步代码块，
这个this 指的是调用fun1方法的class Service的对象，即Thread t1=new Thread(new MyThread1(service)); 
传进去的service.    new Thread(xxx)  这里面传什么参数，要看这个类的构造函数。
   service 拿到这个this 同步锁之后 休眠3秒，这时t2.start(); 开始执行了，fun2()也进入synchronized(this) 同步代码块。
因为这经锁已经被thread1拿到了，所以thread2无法执行同步代码块中的内容，打印不出fun2。
   某些书上说，synchronized锁住的是那一个代码块，当一个线程执行时，另一个线程就不能执行。
其它，这是错误的，例子中thread1和thread2 执行的不是同一个代码块。
  所以，得出结论，synchronized 锁住的不是某一个同步代码块，锁住的是一个对象的同步锁。
一旦某一线程获得了一个对象的同步锁（这里是service对象），那么这个对象上所有的被同步的代码其它的线程通通都不能执行，
但是这个同步锁并不会影响非同步的代码。




程序2：同步方法
[java] view plain copy print?
class Service{  
    public synchronized void fun1{   //方法二：同步方法  
        tyr{  
            Thread.sleep(3000);  
        }  
        catch(Exception e)  
        {  
            System.out.println(e);  
        }  
        System.out.println("fun1");    
    }  
      
    public void fun2{  
         synchronized(this){   //方法一：同步锁  
            System.out.println("fun1");  
         }  
    }  
}  
方法一锁住的对象非常明确，就是this.  那方法二锁住的是哪个对象呢？ 锁住的就是this.

23、Eclipse使用

快捷键
Ctrl + d 删除一行代码
Alt加 /  代码助手
Ctrl + y 再执行一次上一步操作



使用代码生成器（Alt+Shift+s)
自动创建构造函数：右键JAVA代码编辑框，右键，选择Source，选择Generate Constructor using Fields
自动生成ToString()方法，右键，Source，Generate toString()
自动生成hashCode()方法，右键，Source，Generate hashCode()and equals()




杂项功能
注释：选择代码区，按Ctrl + / 。再按一次则取消注释。（这种方法把选中的代码全部单行注释）
   Ctrl + Shift + / 把选择代码用/* */  。 解除注释（Ctrl + Shift + \ ）
Ctrl + Alt  + 方向键下  向下复制光标所在那行代码(intel显卡不行)




代码的重构
书籍推荐《重构—改善既有代码的设计》翻译版


一、改名字
右键包目录下的类名 Refactor  Rename


二、移动
将一个包中的类移动到另一个包中
右键类名 Refactor Move 选择包


三、修改方法(函数)
修改函数名：代码编辑框中选择函数名，右键  Refactor  Change Method Signature
把方法放到父类（父类层）中： 代码编辑框中选择函数名，右键  Refactor  Pull Up
(Pull Down向下，Extract Interface抽取成接口，Extract Superclass抽取成父类，Extract Superclass抽取成单独的类)


四、抽取一片代码（将几行代码抽出来变成函数，适用于某段代码被重复写的情况）
选择代码  右键  Refactor  Extract Method

24、读取Eclipse项目中自己添加的文件

import java.util.Properties;
public class Test{
public static void main(String[]args){
Properties p = new Properties();//一个Properties对象代表一个资源文件
String projectPath = System.getProperty("user.dir");//获取当前项目的路径
String projectPath = projectPath + File.separator+"文件夹"+File.separator+"文件夹"+File.separator+"文件名.后缀"
//File.separator在windowns系统下为“/”，其他系统下位其他系统的文件目录分隔符
//此时就得到了资源文件的路径
InputString in = new FileInputStream(projectPath);
//这样就获取了资源文件
}