Java学习笔记7

lock接口

   

    实现类ReentrantLock

    

    我们可以用lock对象，来对临界资源加锁，只有获得lock对象才能访问临界资源，如果没有获得lock对象，就会进入lock对象的锁池。trylock()方法会返回布尔值，这个方法是用来判断这个锁对象是不是已经被线程获取，如果返回值为true，则会直接获得这个锁对象，如果返回false，线程不会阻塞还会继续运行。

    Lock lock=new ReentrantLock();

    publci void test(){

       try{

      lock.lock();//加锁

      .....//需要加锁的临界资源。

      }finally{

        lock.unlock();//解锁。

      }

    }

   

    ReadWriteLock读写锁接口

   

    ReentrantReadWriteLock是ReadWriteLock的实现类。

   

    readLock()分配读锁，读锁可以分配多个线程，但是在分配读锁后所有读锁释放前，写锁时不能分配的。

    Lock writeLock() 写锁只能分配给一个线程，在分配写锁后写锁是放前，读锁不能被分配。

    

    Condition接口和实现类

   

    await()替代了wait()方法。

    notify()，notifyAll() 在JDK5.0中已经用signal() ，signalAll()方法替换掉了，在JDK5.0中，可以使用多个等待队来存放等待的线程，并对线程进行分类。

    

    Queue接口（Collection的子接口，对列接口）

   

    LinkedList也实现了这个在JDK5.0中的新接口Queue，并且这个类自动的实现了生产者和消费者的同步。

   

   

    JDK5.0的高级同步

    Semaphore类（信号量）也就是可以向线程分配许可证，指定许可证数量可以实现多线程的同步。

    Semaphore s=new Semaphore(4);//可以分配4个许可证，许可证都被分配出去时，得不到许可证的线程就会阻塞。

   

    acquire()方法，获得许可证。release() 方法，释放一个许可证，也有相应的方法指定释放和获得许可证的数量的方法。

   

    CountDownLatch类，

   

    CountDownLatch中有个计数器，访问这个类的对象就会从计数器中减一，countDown()方法会将原有的设置的计数器值减一，当countdown计数器为零时会使放所有await()的线程。

   

    CyclicBarrier类

   

    CyclicBarrier和CountDownLatch比较相似

    CyclicBarrier在构造时给出线程数，只有等待的线程数到了构造方法中指定的数量，当最后一个线程等待后，所有的线程都会被释放，这个类是一个多线程汇合的工具。

   

    Exchanger类，用exchange()方法可以使两个线程间相互交换对象，在两线程的同步点，等待第二个线程。在同步点时，交换对象，并同时被释放。  

   1，       编写程序，求2+4+6+8+…+100的和值，并输出。（10分）

 

2，   求所有满足这样条件的三位整数，并输出。

         百位数字等于十位数字加上个位数字的和。（10分）

        

3，   定义一个int类型的数组，包含10个元素，并赋初值1~10，

         将数组中的每个元素都循环的向前移一个位置，

         如：a[0]=a[1]，a[1]=a[2], a[2]=a[3],…;

         最后一个元素得到原来第一个元素的值。

         然后将这个数组的值循环的输出出来。（15分）

 

4，   定义一个static的方法，要求将一个int型数组中的最大元素返回，

         该方法需要一个int[ ]类型的参数，返回一个int类型的值。

         然后在主方法中去调用这个方法，将结果输出。（15分）

        

5，   定义一个类Person 包含两个私有属性String  name和int  age；

         为这两个属性提供公开的访问方法，

         并写一个构造方法为这两个属性赋值，

         该类还有一个公开的work()方法，输出”working”。（15分）

        

6，   定义一个类Student继承自Person，

         在构造方法中调用父类的有参构造方法，

         覆盖Person类中的work()方法，输出：”Study!!”。 （15分）

        

7，   写一个类Animal，包含两个属性String  name和int  legs；

         要求覆盖toString()方法和equals()方法，

         使得直接输出Animal对象时输出的是对象的name；

         并且当两个对象的name和legs都相同时认为它们相等。（15分）

        

8，   写一个程序，要求运行时从命令行输入不同的值打印不同结果，

         若输入male，则输出“you are a boy!”；

         输入female，则输出“you are a girl!”；

         若输入其他值，则输出“you are wrong!!”。 （15分）

class A{

  public String f(D obj){return ("A and D");}

  public String f(A obj){return ("A and A");}

}

class B extends A{

  public String f(B obj){return ("B and B");}

  public String f(A obj){return ("B and A");}

}

 

class C extends B{}

class D extends B{}

 

 

class TestPoly{

  public static void main(String[] args){

    A a1 = new A();          

    A a2 = new B();

    B b = new B();

    C c = new C();

    D d = new D();

    /*

    一、程序在编译的时候，编译器会根据类型找到个重装的方法；

    二、运行的时候会根据实际类型找到覆盖之后的方法

    */

    System.out.println(a1.f(b));  // A and A

    /*

    对a1调用f(b)，a1是A类对象，

    b对象的编译时类型是B，到A类中找方法，

    只能对一个对象调用其编译时的类型定义的方法，

    此时编译器会a1编译时类型A类中找方法，

    到A类中找f(b)，但A类中没有f(b)，

    所以要遵守向上就近匹配原则，没B类，找A类。

    编译时绑定了“public String f(A obj){return (" A and A");}”

    运行时，a1的实际类型就是A类型的，所以就找这个方法。

    */

   

    System.out.println(a1.f(c));   //A and A

    //同上面

   

    System.out.println(a1.f(d));   //A and D

    //这个直接找到

 

    System.out.println(a2.f(b));   //B and A

    /*

    用b参数对a2调用f(b)方法，a2编译时类型是A，

    在编译时找个方法，找f(B obj)，但没找到，

    所以只好找到A类中 f(A obj)

    运行时，a2时运行时类型是B，运行时根据运行时类型找覆盖后的方法

    B类运行有对A类中 f(A obj)这个方法的覆盖，

    是B类中 f(A obj)，所以输出“B and A”

    */

   

    System.out.println(a2.f(c));   //B and A

    //同上

   

    System.out.println(a2.f(d));   //A and D

    //这个直接找到

   

    System.out.println(b.f(b));    //B and B

    //直接找到

   

    System.out.println(b.f(c));    //B and B

    //C类型向上就近到B类型

   

    System.out.println(b.f(d));    //A and D                       

    /*

    */

  }

}】

第一题：

  要求为以前写的栈实现Iterable接口，使之成为可循环遍历的类。

 

第二题：

1，定义一个Course类，代表课程；定义一个Student类，代表学生，在Student类中包含一个属性是一个HashSet的对象，用来存储该学生所选的所有课程，并提供相应的addCourse(Course c)方法和removeCourse(String name)方法，表示添加一门选课和删除一门选课（删除选课时通过传课程名参数来确定）。

2，定义一个类SchoolClass代表班级，该类中包含一个属性是一个HashSet的对象，用来存储该班级中所有的Student,并提供相应的addStudent(Student s)方法和removeStudent(String name)方法，表示添加一名学生和删除一名学生（删除学生时通过传学生姓名参数来确定）。

3，在主方法中生成一个SchoolClass对象，添加若干个学生，并且为每个学生添加若干门课程，最后要统计出每门课程的选课人数。

 

第三题：

1，定义一个Teacher类，包含3个属性：name,age,salary。并且定义若两个对象的name和age都相同，则认为这两个对象相等。

要求该Teacher类对象能比较大小，按照age的大小来排序，如果age相同的则按salary大小来排。

最后，生成一些Teacher对象，加入到HashSet和TreeSet中验证以上程序的正确性。

 

第四题：

定义以下类，完成后面的问题，并验证。

Exam类   考试类

属性： 若干学生  一张考卷

提示：学生采用HashSet存放

 

Paper类   考卷类 

属性：若干试题

提示：试题采用HashMap存放，key为String，表示题号，value为试题对象

 

Student类     学生类

属性：姓名   一张答卷   一张考卷

 

Question类    试题类

属性：题号 题目描述    若干选项    正确答案

提示：若干选项用ArrayList

 

AnswerSheet类    答卷类

属性：每道题的答案   

提示：答卷中每道题的答案用HashMap存放，key为String，表示题号，value为学生的答案

 

 

问题：为Exam类添加一个方法，用来为所有学生判卷，并打印成绩排名（名次、姓名）

Day6

 

1 接口:定义接口关键字interface,接口是一种特殊的抽象类

  接口中的所有方法默认都是public abstract方法

  接口中的所有属性默认都是public static final的属性

 

2 一个类可以实现多个接口class A implements interfaceIA,interfaceIB

  所谓实现一个接口就是实现接口里定义所有的方法,关键字implements

  接口的父类不能是类.  interfaceIA extends classA   !!!error

 

 

3 子类   父类

 

  接口    类     !error

  接口    接口   多继承 关键字extends  

  类      类     单继承

  类      接口   implements接口

 

4 接口中没有构造方法.

 

5 泛化:由子类抽象出父类的过程

  特化:由父类扩展出子类的过程

 

6 接口作用:把标准的制定者和标准的实现者分离,易于可扩展性和可移植性.

  接口回调:先有接口的定义，再有接口的使用者，最后把接口的实现者传到接口的使用者中，

  接口的使用者会通过接口来调用接口实现者的方法。

 

  public class TestJDBC {

         public static void main(String []args){

                   Driver d=getDriver(args[0]); 

                   d.connect();

         }

         static Driver getDriver(String name){

                   if(name.equals("MySQL")) return new MySQLDriver();

                   else if(name.equals("DB2")) return new DB2Driver();

                   else return new OracleDriver();

         }

  }

  interface Driver{

         void connect();

  }

  class MySQLDriver implements Driver{

         public void connect() {

                   System.out.println("connected MySQLDriver");     

         }      

  }

 

  class DB2Driver implements Driver{

         public void connect() {

                   System.out.println("connected DB2Driver"); 

         }      

  }

 

  class OracleDriver implements Driver{

         public void connect() {

                   System.out.println("connected OracleDriver");        

         }      

  }

 

7 注意点：

  (1)一个文件只能有一个public接口，且与文件名相同.

  (2)在一个文件中不能同时定义一个public接口和一个public类.

  (3)接口与类之间只有实现关系，没有继承关系.

  (4)抽象类与类之间只有继承关系没有实现关系.

  (5)接口与接口之间只有继承关系，且允许多继承.

  (6)接口中可以不写public,但在子类实现接口的过程中public不可省略.

 

8  接口和抽象类

  (1)接口中不能有具体的实现，但抽象类可以。

  (2)一个类要实现一个接口必须实现其里面所有的方法，而抽象类不必。

  (3)通过接口可以实现多继承,而抽象类做不到。

  (4)接口不能有构造方法，而抽象类可以。

  (5)实体类与接口之间只有实现关系，而实体类与抽象类只有继承关系。

 

9  修饰符      类    属性   方法   局部变量

 

   final       *      *      *       *

   static             *      *     

   abstract    *             *

   public      *      *      *

   protected          *      *

   default     *      *      *

   private            *      *

 

10 ==和equals的区别

 

  基本类型用==去比较比的是值是否相等.

  如果是对象用==比是两个引用中的地址值是否相等

  判断两对象内容是否相等时用equals()方法,equals 比较两个对象内容是否相等.

 

11 toString()方法:给出这个对象的字符串表达形式,返回一个字符串.

   当直接打印出对象的引用,它实际输出的是这个对象的toString()方法的返回值.

   Student s1=new Student();

   System.out.println(s1);     // toStrint()方法的返回值

 

   Object类toString()方法返回值两部分: 包名加类名@地址 day5.Student@757aef

   在java里只能用这个方法来看对象的地址,但只能看,不能操作这个地址.

 

   字符串相加时,也会去调toStirng()方法,"hello"+str1.

 

12 主方法的参数:字符串数组argv   java Test  argv[0] 

   //与c++不同,命令行第三个元素才是数组的第一个元素

   主方法是程序的入口,主方法必须声明为静态的.

 

 

13字符串赋值形式:

 

  String s1=new String("haha");   //新开辟空间,生成一个新的字符串对象.

  String s2="haha";               //在串池找

    

  int a=5;

  int b=a<<33;

  System.out.println(b);   //结果b=10,移位运算时系统会对32求余

 

14 对于字符串:

   (1)对象池

   (2)不变模式: 生命周期内值不变, String s1=new String("Hello"); 

   一个字符串实际是用一个字符数组来作底层的保存空间,所以不可改变值.

 

  在需要频繁改变字符串值时建议用StringBuffer() 可以改变值,不创建新对象

 

15 基本类型的包装类.把基本类型包装成相应的类类型.符合一切皆对象的天理.

   八种,保留基本类型效率高.

 

  除了int 和char，其余类型首字母大写即成包装类

  int          Integer

  char                 Character

 

  int Integer String之间的类型转换(最常用的)

  int a =12;

  int      到   Integer          Integer aa = new Integer(a)；

  Integer  到   int          int  i = aa.intValue()；

  Int      到   String       String  str = String.valueOf(i)；

  String   到   int          int  ii = Integer.parseInt(str)；

  Integer  到   String       String  str = aa.toString()；

  String   到   Integer      Integer bb = Integer.valueOf(str)；

 

  int a=20;

  String s=a+"";  //加空串也可以得到一个字符串.

 

 

下载、安装Eclipse 

 

进入Eclipse项目的主页http://www.eclipse.org，点击Downloads，进入下载页。

 

Eclipse最新的版本是3.3版，但是3.3版的多国语言翻译包还没有出来，所以我们可以使用一个稍早一点的版本3.2。

 

点击3.2进入其下载页，这个页面有很多下载连接，包括Eclipse SDK在很多平台上的版本；

 

这里我们只需要下载eclipse-SDK-3.2-win32.zip将这个文件解压缩到磁盘的目录，如D:\eclipse。

 

在运行Eclipse之前首先应该安装好JDK，设置好环境变量JAVA_HOME、CLASSPATH和PATH。

 

为D:\eclipse下的eclipse.exe在桌面上建立一个快捷方式。双击快捷方式启动Eclipse。

 

==========================================================================================================

 

设置JRE:

 

1.选择Window->Preferences,然后选择Java->Installed JREs,然后选择jre1.5.0_07,单击Edit按钮.

 

2.单击Browse按钮,选择JDK的安装路径,然后单击OK确定.这样Eclipse下的JDK就已经设置完成了.

 

==========================================================================================================

 

第一个Eclipse工程：下面我们编写一个简单的HellWorld程序，步骤如下：

 

1．选择File->New->Project

 

2．项目列表选Java Project

 

3．点击“下一步”； 

 

4．输入项目名称，例如：Java；选择相应的JRE(默认即可); 然后选择字解码文件和源文件分离.

 

5．点击Finish;

 

6. 鼠标移动到src目录下单击鼠标右键,New->Package,新建一个包,然后输入包名;

 

7．在工具条里点击“创建Java类”的按钮（带有一个C标记）;

 

8．在名称域输入HelloWorld；

 

9．点击public static void main(String[] args) 的复选框，让Eclipse创建main方法;

 

10．点击Finish;

 

11．一个Java编辑窗口将打开，在main方法中输入System.out.println(“Hello World”)行； 

 

12．使用Ctrl-s保存，这将自动编译 HelloWorld.java；

 

13．点击工具条里的Run As按钮；然后选择Java Application项运行程序

 

14．这时候，将会打开一个控制台窗口，一句“Hello World”将会显示在里面。

 

==========================================================================================================

 

eclipse常见问题：

 

1.如何将建立eclipse的快捷方式?

 

答:在桌面单击右键选择新建启动器,填上名字和命令的路径(即/opt/eclipse/eclipse).

 

 

2.如何显示行号?

 

答:选择Window->Preferences,然后选择General->Editors->Text Editors,把show line numbers选项勾上.

 

 

3.如何改变java源文件字体大小?

 

答:选择Window->Preferences,然后选择General->Appearance->Colors and Fonts->Java->Java Editor Text Font

 

   然后选择Change按钮就可以改变字体大小了.

 

 

4.如何去掉自动生成注释?

 

答: 选择Window->Preferences,然后选择Java->Code &#115;tyle->Code Templates,选择Comments和Code选项中的内容,

 

    单击Edit按钮,把默认的注释删掉就可以了.

 

 

5.为何刚刚拷贝过来的文件不能立即显示?

 

答:需要在你刚刚做过更新的目录上点击右键,然后选择Refresh,刷新该目录即可显示.

 

 

6.Eclipse常用快捷键:

Ctrl+Enter:跳到下一行行首

Alt+Shift+X+J:运行当前程序

Ctrl+F11:运行上次编译过的程序

Shift+Ctrl+F:格式化代码

Shift+Ctrl+X:将所选字符转为大写

Shift+Ctrl+Y:将所选字符转为小写

Ctrl+1:迅速定位错误处理

Ctrl+M:快速对当前视图最大化

Alt+Shift+S:快速显示Source选项

Alt+/:代码注释

Ctrl+/:代码注释/取消注释

Ctrl+D:删除光标所在行 

Ctrl+鼠标停留:可以显示类和方法的源码

Ctrl+Shift+S:保存全部