国产精品一区毛片,国产精品国产三级国产普通话三级,在线资源av

闫佳 — Mon, 08 Nov 2010 15:20:00 GMT

定义�U�程有两�U�方法，一�U�是�l�承Thread�c�，一�U�是实现Runnable接口�Q�这两种�Ҏ��存在各自的优�~�点。和定义�U�程对应的就是创建线�E�对象，也有两种�Ҏ��。下面给大家介绍一下这两种�Ҏ��来定义线�E�及相对应的创徏�U�程对象的方法�?/p>

1.�l�承Thread�c�d��义线�E?/p>

定义一个线�E�可以通过�l�承Thread�c�L��实现�Q�这是一�U�相对简单的定义�U�程的方法。在Thread�c�M��有一个run�Ҏ��Q�在定义的线�E�中需要重写这个方法。在重写run�Ҏ��中可以定义该�U�程要执行的语句。当�U�程启动�Ӟ��run�Ҏ��中的�E�序��成��Z��条独立的执行�U�程。示例代码如下：

public class XianCheng extends Thread

{

public void run()

{

System.out.println("run�Ҏ��执行");

}

改程序是无法执行的，因�ؓ没有main�Ҏ��Q�也��是没有启动�U�程的方法。下面先介绍如何创徏�U�程对象。代码如�?

XianCheng xc = new XianCheng();

从上面的代码可以看出�Q�创建线�E�对象的�Ҏ��和创建普通对象的�Ҏ��是一��L��。但是这只是对于使用�l�承Thread�c�d��建线�E�的�Ҏ��来说的。我们也可以通过Thread�c�L��定义�U�程对象�Q�如

Thread th = new Thread�Q�）�Q?/p>

2.实现Runnable接口定义�U�程

在Runnable接口中具有一个抽象的run�Ҏ��Q�在实现Runnable接口�Ӟ��需要实现run�Ҏ��。示例代码如下：

public class test2 implements Runnable{

public void run�Q�）{

System.out.println("run�Ҏ��执行");

}

在��用实现Runnable接口定义的线�E�中�Q�要比上面复杂些�Q�因为直接创建类的对象创建的�q�不是一个线�E�对象，要想创徏�U�程对象必须要借助Thread�c�R��只有Thread�c�L��能定义线�E�对象�?/p>

代码如下�Q�test2 t2 = new test2�Q�）�Q?/p>

Thread tt2 = new Thread�Q�t2�Q�；

tt2才是�U�程对象�Q�Thread�c�d��?个构造器�Q�最常用的就是具有一个参数的�Q�我们可以先创徏一个实现Runnable接口的类对象�Q�然后作为Thread�cȝ��参数来创建多个线�E�对象�?/p>

当我们徏立了一个线�E�类的时候，��p��启动�U�程�Q�初学者会认�ؓ启动�U�程��是调用�U�程�c�M��的方法。但�q�点是错误的�Q�虽然可以用对象�?run�Q�）来调用run�Ҏ��Q�但�q��ƈ不是�U�程的启动。要惛_��动线�E�还要调用线�E�的star�Ҏ��Q�如�Q�tt2.start�Q�）�Q�但要注意，一个线�E�只能调用一�ơstar�Ҏ��Q�第二次启动�U�程会发生IllegalThreadException异常。有关线�E�的启动�Q�应用问题以后再做介�l��?/p>

好了�Q�有关线�E�的基础知识先介�l�到�q�里。有不��的地方请大家批评指正�?/p>

闫佳 2010-11-08 23:20 发表评论

闫佳 — Thu, 04 Nov 2010 02:59:00 GMT

学Java也有好一阵子了，当涉及到Java的实际应用时发现自己的基��跟不上。基��不行�Q�概念不清，对以后的学习造成不小的负面媄响。仔�l�分析后�Q�自己�ȝ��了一些Java里面很基��的东西，希望以后把基��打好�Q�高手就不必�q�目了呀�Q�哈哈~~~

一、有关super跟this的区别�?/p>

区别	Super	This
范围	由子�c�访问父�cȝ��内容	直接讉K��本类中的内容
讉K��属�?/p>	super.父类属性，如果属性没有被覆写�Q�则也可以不写super�?/p>	This.本类属性�?/p>
讉K��Ҏ��	super.父类�Ҏ��(),如果�Ҏ��没有被覆写，则可以不用加super也表�C��用父�c�M��的方法�?/p>	this.本类�Ҏ��(),可以不写this,也表�C��用本�cȝ��Ҏ��?/p>
讉K��构造方�?/p>	super是访问父�c�M��的构造方法，必须攑֜�首行�?/p>	this 是访问本�c�M��的其他构造方法，必须攑֜�首行�?/p>

二、重载和重写的区别�?/p>

区别	重蝲	重写/覆写
单词	Overloading	Override
概念	�Ҏ��名称相同�Q�参数列表不同�?/p>	�Ҏ��名称相同�Q�参数列表相同，�Ҏ��的访问权限不能更严格�?/p>
范围	发生在一个类中�?/p>	发生在��承关�p�M��Q�由子类�q�行覆写�?/p>

三、Vector和ArrayList

1.vector是线�E�同步的�Q�所以它也是�U�程安全的，而arraylist是线�E�异步的�Q�是不安全的。如果不考虑到线�E�的安全因素�Q�一般用
arraylist效率比较高�?br> 2.如果集合中的元素的数目大于目前集合数�l�的长度�Ӟ��vector增长率�ؓ目前数组长度�?00%,而arraylist增长率�ؓ目前数组长度

�?0%.如过在集合中使用数据量比较大的数据，用vector有一定的优势�?br> ArrayList 和Vector是采用数�l�方式存储数据，此数�l�元素数大于实际存储的数据以便增加和插入元素�Q�都允许直接序号索引元素�Q?br> 但是插入数据要设计到数组元素�U�d��{�内存操作，所以烦引数据快插入数据慢，Vector�׃��使用了synchronized�Ҏ��Q�线�E�安全）所以性能上比ArrayList要差�Q?br> LinkedList使用双向链表实现存储�Q�按序号索引数据需要进行向前或向后遍历�Q�但是插入数据时只需要记录本��的前后��即可，所以插入数度较快！

四、arraylist和linkedlist

1.ArrayList是实��C��Z��动态数�l�的数据�l�构�Q�LinkedList��Z��链表的数据结构�?br> 2.对于随机讉K��get和set�Q�ArrayList觉对优于LinkedList�Q�因为LinkedList要移动指针�?br> 3.对于新增和删除操作add和remove�Q�LinedList比较占优势，因�ؓArrayList要移动数据�?br> �q�一点要看实际情�늚�。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList�?br> 但若是批量随机的插入删除数据�Q�LinkedList的速度大大优于ArrayList. 因�ؓArrayList每插入一条数据，要移动插入点及之后的所有数据�?

五、HashMap与TreeMap

1、HashMap通过hashcode对其内容�q�行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得��C��个有序的�l�果你就应该使用TreeMap�Q�HashMap中元素的排列��序是不固定的）�?

HashMap中元素的排列��序是不固定的）�?

2、HashMap通过hashcode对其内容�q�行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得��C��个有序的�l�果你就应该使用TreeMap�Q�HashMap中元素的排列��序是不固定的）。集合框架”提供两�U�常规的Map实现�Q�HashMap和TreeMap (TreeMap实现SortedMap接口)�?

3、在Map 中插入、删除和定位元素�Q�HashMap 是最好的选择。但如果您要按自焉��序或自定义顺序遍历键�Q�那么TreeMap会更好。��用HashMap要求��d��的键�c�L��定义了hashCode()�?equals()的实现。　　�q�个TreeMap没有调优选项�Q�因��树��d��于��^衡状态�?

六、hashtable与hashmap

1.历史原因:Hashtable是基于陈旧的Dictionary�cȝ��Q�HashMap是Java 1.2引进的Map接口的一个实�?

2.同步�?Hashtable是线�E�安全的�Q�也��是说是同步的，而HashMap是线�E�序不安全的�Q�不是同步的

3.��|��只有HashMap可以让你��空��g��Z��个表的条目的key或value

七、Set中的数据对象没有��序且不可以重复�?br> List中的数据对象有顺序且可以重复�?

闫佳 2010-11-04 10:59 发表评论

闫佳 — Wed, 03 Nov 2010 03:03:00 GMT

我们知道面向对象语言的三大特征是��装、��ѝ��多态。我们在定义了一个类之后�Q�可以通过再定义一个类�Q�且�q�个�cȝ��承上一个类来扩展其功能。其实，在我们定义类�Ӟ��c�M��的成员变量除了基本数据类型也可以是引用数据类型。下面我��编写一个有关类成员变量中引用数据类型��用的例子�?/p>

在这个程序中�Q�首先定义一个学校类�Q�再定义一个班�U�类�Q�最后定义一个学生类。在�ȝ��序中通过讄��不同�c�d��对象间的关系�Q�达到类与类之间包含的关�p�R�?/p>

代码如下�Q?/p>

//学校�c?/p>

package com.TinySK;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
class School{
        private String name;
        //一个学校有多个班�� Q�通过集合�c�List 实现�?
        private List allClss;
        public School(String name){
                this.setName(name);
                this.setAllClss(new ArrayList());
        }
        //向学校中加入班��
        public void add(Cls cls){
                this.allClss.add(cls);
        }
        public void setName(String name){
                this.name = name;
        }
        public String getName(){
                return this.name;
        }
        public void setAllClss(List allClss){
                this.allClss = allClss;
        }
        public List getAllClss(){
                return this.allClss;
        }
}

//班��c?/p>

class Cls{
        private String name;
        private School school; //此处定义了一个学校类的对象�?nbsp;
        private List allStudents;//一个班�U�有多个学生 �Q�通过集合�c�List 实现�?/p>

       public Cls(String name){
                this.setName(name);
                this.setAllStudents(new ArrayList());
        }
        //向班�U�中加入学生
        public void add(Student stu){
                this.allStudents.add(stu);
        }
        public List getAllStudents(){
                return this.allStudents;
        }
        public void setAllStudents(List allStudents){
                this.allStudents = allStudents;
        }
        public void setSchool(School school){
                this.school = school;
        }
        public School getSchool(){
                return this.school;
        }
        public void setName(String name){
                this.name = name;
        }
        public String getName(){
                return this.name;
        }
}

//学生�c?/p>

class Student{
        private String name;
        private int age;
        //一个学生属于一个班�U?nbsp;
        private Cls cls;
        public Student(String name,int age){
                this.setName(name);
                this.setAge(age);
        }
        public void setName(String name){
                this.name = name;
        }
        public String getName(){
                return this.name;
        }
        public void setAge(int age){
                this.age = age;
        }
        public int getAge(){
                return this.age;
        }
        public void setCls(Cls cls){
                this.cls = cls;
        }
        public Cls getCls(){
                return this.cls;
        }
}

//��d��?

public class Test{
        public static void main(String[] args){
                School sch = new School("Java blog");
                Cls c1 = new Cls("Java一�?);
                Cls c2 = new Cls("Java二班");
                Cls c3 = new Cls("Java三班");
                Student stu1 = new Student("Tiny",20);
                Student stu2 = new Student("SK",25);
                Student stu3 = new Student("sevn",23);
                Student stu4 = new Student("puck",28);
                Student stu5 = new Student("lion",35);
                //讄��关系
                sch.add(c1);
                c1.setSchool(sch);
                sch.add(c2);
                c2.setSchool(sch);
                sch.add(c3);
                c3.setSchool(sch);
                c1.add(stu1);
                stu1.setCls(c1);
                c2.add(stu2);
                stu2.setCls(c2);
                c2.add(stu3);
                stu3.setCls(c2);
                c3.add(stu4);
                stu4.setCls(c3);
                c3.add(stu5);
                stu5.setCls(c3);
                //如果要输出全部的内容�Q�则要进行双重��@�?nbsp;
                System.out.println("学校名称�Q?+sch.getName());
                Iterator iter1 = sch.getAllClss().iterator();
                while(iter1.hasNext()){
                        Cls c = iter1.next();
                        System.out.println("\t|- 班��名称�Q?+c.getName());
                        //输出一个班�U�中的全部学�?nbsp;
                        Iterator iter2 = c.getAllStudents().iterator();
                        while(iter2.hasNext()){
                                Student s = iter2.next();
                                System.out.println("\t\t|- 学生姓名�Q?+s.getName()+"�Q�学生年龄："+s.getAge()+" --> "+s.getCls().getSchool().getName());
                        }
                }
        }
}

�q�行�l�果如图�Q?a href="http://www.aygfsteel.com/images/blogjava_net/TinySK/WindowsLiveWriter/f842ac4a449b_9B6C/_OM38%5B@O$QC@2%7BVTXN%60E9A1_2.jpg">

本例�q�没有什么太多的隄��Q�只是想�H�出一下类与类之间的关�p�R��本文到此结束，有很多不��之处望大家批评指正�?/p>

闫佳 2010-11-03 11:03 发表评论

对象引用间的比较问题

闫佳 — Tue, 19 Oct 2010 06:03:00 GMT

两个对象引用�q�行比较�Q�比较的是这两个对象的引用，而引用是在内存中的一个地址。当然在�q�之前我们一定要清楚引用数据�c�d��的堆栈二�D�式内存��理模式。下面通过一个例子来掩饰引用间的比较�?/p>

public class Obj {
    public static void main(String [] args)
       {
               Obj t1=new Obj();
               Obj t2=new Obj();
               if(t1.equals(t2))
          {System.out.println("true");
          }
          else
          {
              System.out.println("false");
          }
       }
}

�q�行�l�果为： false

equals�Ҏ��在这里比较的是对象的引用�Q�用new关键字创建的对象地址是重新分配的�Q�它们进行比较地址当然是不同的�?

下面对上面的�E�序�q�行扩展�Q?

public class Obj {
     public String name;
     public int age;
     public void say(){
      System.out.println("姓名�Q?+name+" �q�龄�Q?+age);
     }
public static void main(String [] args)
       {
                Obj t1=new Obj();
                Obj t2=new Obj();
                Obj t3=new Obj();
                      t3=t1;
          if(t1.equals(t2))
          {System.out.println("true");
          }
          else
          {
              System.out.println("false");
          }
                 t1.name="Tiny";
                 t1.age=20;
                 t1.say();
                 t2.name="SK";
                 t2.age=10;
                 t1.say();
                 t2.say();
                 t1=t2;
        if(t1.equals(t3))
          {System.out.println("true");
          }
          else
          {
              System.out.println("false");
          }
                 t1.say();
                 t2.say();
                 t3.say();
        if(t3.equals(t2))
        {System.out.println("true");
        }
        else
        {
            System.out.println("false");
        }
       }
}

�q�行�l�果如图�Q?a href="http://www.aygfsteel.com/images/blogjava_net/TinySK/WindowsLiveWriter/1bdef11c5df1_C4C4/%7DU%5D9%60G%60)M%7D7N%7B)IFQ%7B%7DXL00_2.jpg">

有关�E�序的具体执行，通过图例演示�Q�如下：

                Obj t1=new Obj();
                Obj t2=new Obj();
                Obj t3=new Obj();

创徏Obj�cȝ��实例�Q�在内存中开辟存储空间�?a href="http://www.aygfsteel.com/images/blogjava_net/TinySK/WindowsLiveWriter/1bdef11c5df1_C4C4/clip_image001_2.gif">

当执行t3=t1;�Ӟ��内存中存储�Ş式变为：

原来t3所指向的那块堆内存��变为“垃�䏀�。由java垃圾回收机制自动回收�?/p>

if(t1.equals(t2))
          {···· }
          else
          {···· }输出�l�果当然�?false了�?/p>                 t1.name="Tiny";
                 t1.age=20;
                 t1.say();
                 t2.name="SK";
                 t2.age=10;
                 t1.say();
                 t2.say();

执行完这几条语句后，内存�l�果为：

至于t1.say();和t2.say();�q�两条语句的�l�果我就不用多说了吧�Q�下面是关键部分�Q�当执行t1=t2;后内存中存储�l�果为：

最后执行的那几步应该就很清��C��Q�整个程序的��程到此�l�束�?nbsp;

闫佳 2010-10-19 14:03 发表评论