JAVA学习笔记(二)

内容：

JAVA常用包

＝＝和equals的用法

基本数据类型和引用数据类型

String 和StringBuffer

对象的克隆（clone）

数组的相关操作

封装类

Runtime类和Process类

Class类

设计模式

1.       Java命名规则

package的命名：全部由小写字母组成。cn.cauthy

class 和interface的命名：全部由大写字母开头而其他字母都是小写的单词组成。Person   RuntimeException

class变量的命名：变量的名字用一个小写字母开头，后面的单词用大写字母开头。index   currentImage

class方法的命名：方法的名字用一个小写字母开头，后面的单词用大写字母开头。run()  getBalance()

static final 变量的命名：所有字母都大写，并且能表示完整含义。PI   PASSWORD

参数的命名：与变量的命名一致

数组的命名：总是这样命名：byte[]buffer

2.       Java常用包

java.applet:包含一些用于创建Java小应用程序的类

java.awt:包含一些用于编写与平台无关的图形界面（GUI）应用程序的类

java.io:包含一些用于输入输出的类

java.lang:包含一些Java语言的基本类和核心类，如String,Math,Integer,System和Runtime类，提供常用的功能，这个包中的所以类是被隐式导入的。

java.net:包含用于创建网络连接的类，与java.io包同时使用完成与网络相关的读写

java.util:包含一些实用工具类和数据结构类。

3.==与equals

     Java语言中的八种基本类型，除此之外都是引用类型。

     ==是比较两个值是否相等，而equals比较两个对象变量所代表的对象的内容是否相等。当我们声明一个引用类型的变量的时候，系统只为该变量分配了引用空间，并未创建一个具体的对象，当用new为对象分配空间后，将对象的引用赋值给引用对象。

在Java中，String类重载了+ +=的操作，是Java中唯一的，而且java不允许程序员自己重载运算符。

class StringTest

{

    public static void main(String []args)

    {

   If(args.length>0)

{

    for(int i = 0;  i <args.length; i++)

{

           System.out.println(args[0]);//在执行java StringTest时候应该给予命令行的参数，如果没有，则会抛出异常。这个命令行参数会保存在这个数组中。

           System.out.println(args[1]);

}

}

                String str1=new String ("abc");

                String str2=new String ("abc");

        String str3=str1;

  /*        if(str1==str2)

      {

             System.out.println("Str1==Str2");

      }

      else

      {

             System.out.println("Str1!=Str2");

      }*/

/*          if(str1==str3)

      {

             System.out.println("Str1==Str3");

      }

      else

      {

             System.out.println("Str1!=St3");

      }*/

 /*         if(str1.equals(str2))

      {

             System.out.println("Str1==Str2");

             int[] arrary=new int[]{0,1,2,3};

             System.out.println(str1+arrary[1]);

         //array=null;//这是分配的四个int的堆内存成为垃圾内存array与对象失去联系

      }

      else

      {

             System.out.println("Str1!=Str2");

 

      }*/

/*          char ch='a';

      float f= 1.1f ;

      boolean ben=false;

      StringBuffer str=new StringBuffer ("abc");//初始容量为16个字符，如果超过了，容量会自动增加。

      str.append(ch).append(f).append(ben);//有很多重载的函数，返回一个StringBuffer对//象的引用,有一个函数toString方法，将一个StringBuffer的对象转换为String

    System.out.println(str.toString());//toString方法其实被自动调用。只要是打印的时候，对象都自动调用toString方法。

//           str.delete(0,4);//删除第0到第3个（也删除）即删除包含起始位置，不包含结束位置。=>0;<4

      str.insert(1,'2');

      System.out.println(str+"capacity is"+str.capacity());*///返回容量大小

/*          Student[] students;//产生对象引用，但没有赋值，故为null

students =new Student[3];//在堆上分配内存，即对象引用指向了这个堆内存，但是初始为null

      for(int i=0;i<students.length;i++)

      {

             System.out.println(students[i]);//输出三个null

      }*///对象数组，没有用new分配空间的时候，产生一个对象，在堆栈中，有了new，在堆内存中

      //分配了三个为null的元素，堆栈中保存了首地址。

}

}

class Student

{

    String name;

    int age;

    Student(String name,int age)

    {

         this.name=name;

         this.age=age;

    }

}上例中，str1指的是内存地址，当然不会与str2相等了。若要比较他们的内容时候相等要使用equals.(System类的函数，)str1的值被分配在堆内存，而str1指的是栈内存。

String类重载了”+””+=”是Java中唯一重载，而且不允许程序员重载。String类型是常量，即赋值过后就确定了，如果重新赋值，则上一个就成了垃圾内存了。即改变了它的引用。

StringBufer可以动态改变字符串。

3.       Java中函数的调用都是值传递。基本数据类型传递的是数据的拷贝（8种基本类型），引用类型传递的是引用的拷贝。（如数组，对象）引用就是对象的“地址”

4.       toString方法的覆盖

子类应该覆盖基类Object方法，任何打印System.out.println(str);自动调用str.toString()方法。如果子类没有这个方法的时候，它会调用基类的toString方法，返回这个对象的散列码（对象名@哈希码），并且建议我们覆盖这个方法。

5.       克隆（clone）对象引用的拷贝，利用Object类的clone()方法

实现克隆的步骤方法：

在派生类中覆盖基类的clone()方法，并声明为public

在派生类的clone()方法中，调用super.clone()

在派生类中实现Cloneable接口。//该接口中没有方法，其实就是告诉编译器该对象具有克隆的能力了。

       如果不用克隆的话，将一个对象直接赋值给另外一个对象，他们共享同一个内存空间，可以通过改变任何一个对象引用的值改变内存的值。而通过对象引用就可以将他们分开。而使用了克隆之后，就产生了两个对象。

class StringTest

{

       public static void main(String []args)

       {

              Professor p=new Professor("wangwu",50);

              Student s1=new Student("zhangsan",18,p);

//            Student s2=s1;

    Student s2=(Student)s1.clone();

    s2.p.name="lisi";

    s2.p.age=30;

              System.out.println("name is "+s1.p.name+","+"age is"+s1.p.age);

             

/*             System.out.println(args[0]);

                System.out.println(args[1]);

                     String str1=new String ("abc");

                     String str2=new String ("abc");

           String str3=str1;*/

  /*      if(str1==str2)

           {

                  System.out.println("Str1==Str2");

           }

           else

           {

                  System.out.println("Str1!=Str2");

           }*/

/*        if(str1==str3)

           {

                  System.out.println("Str1==Str3");

           }

           else

           {

                  System.out.println("Str1!=St3");

           }*/

 /*       if(str1.equals(str2))

           {

                  System.out.println("Str1==Str2");

                  int[] arrary=new int[]{0,1,2,3};

                  System.out.println(str1+arrary[1]);                

           }

           else

           {

                  System.out.println("Str1!=Str2");

 

           }*/

/*        char ch='a';

           float f= 1.1f ;

           boolean ben=false;

           StringBuffer str=new StringBuffer ("abc");

           str.append(ch).append(f).append(ben);

//         str.delete(0,4);

      str.insert(1,'2');

           System.out.println(str+"capacity is"+str.capacity());        */

/*        Student[] students=new Student[3];

           for(int i=0;i<students.length;i++)

           {

                  System.out.println(students[i]);

           }*///对象数组，没有用new分配空间的时候，产生一个对象，在堆栈中，有了new，在堆内存中

           //分配了三个为null的元素，堆栈中保存了首地址。

}

}

 

class Student implements Cloneable

{

       String name;

       int age;

       Student o=null;

       Professor p;

       Student(String name,int age,Professor p)

       {

              this.name=name;

              this.age=age;

              this.p=p;

       }

       public Object clone()

       {

             

              try{

                    o=(Student)super.clone();

                  }

              catch(CloneNotSupportedException e)

              {

                     System.out.println(e.toString());

              }    

              o.p=(Professor)p.clone();//深层次的拷贝，如果有多个类似的引用变量，则类似

              return o;              //多次调用这种方法

       }

}

 

class Professor implements Cloneable

{

       String name;

       int age;

       Object o=null;

       Professor(String name,int age)

       {

              this.name=name;

              this.age=age;

       }

              public Object clone()

       {

             

              try{

                    o=super.clone();

                  }

              catch(CloneNotSupportedException e)

              {

                     System.out.println(e.toString());

              }    

 

              return o;

       }

}

学生类中 包含了 教授类的对象，教授类的对象要实现克隆，必须也得覆盖clone()方法，并且在学生类中调用教授类的克隆方法，这样，在学生类进行克隆的时候才能够成功。否则因为克隆是拷贝变量的值，而对引用变量是拷贝引用变量的值。所以改变第二个对象中的教授的值可以改变第一个教授的值。而对String类的对象与教授类的对象不同，虽然String类中没有重写克隆方法，但是String类型的对象是常量。当类中没有引用类型的变量时，我们称之为浅层次的拷贝。

为什么在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()方法识别出你要复制的是哪一个对象，然后为次对象分配控件，并进行对象的复制，将原始对象的内容――复制到新对象的存储空间中。

6.       数组的应用

1）  数组的拷贝（对象引用，没有克隆）System.arraycopy();

2）  数组的排序（升序）对象的排序需要实现接口Comparable，然后重写 public int compareTo(Object o)确定对象按照什么顺序排序。Arrays.sort()需要导入包java.util.Arrays

3）  数组的查找

4）  代码如下

        import java.util.*;

class ArrayTest

{

       public static void main(String []args)

       {

/*        int[] aa=new int[]{3,2,1};

           int[] bb=new int[3];

           System.arraycopy(aa,0,bb,0,aa.length);

           Arrays.sort(bb);

           for(int i=0;i<bb.length;i++)

           {

                  System.out.println(bb[i]);

           }*/

           Student[] ss=new Student[]{new Student("zhangsan",1),new Student("lisi",2),

                                           new Student("wangwu",3),new Student("wang",3)};

           Arrays.sort(ss);

           for(int i=0;i<ss.length;i++)

           {

                  System.out.println(ss[i]);

           }

    }

}

class Student implements Comparable

{

       String name;

       int num;

       Student(String name,int num)

       {

              this.name=name;

              this.num=num;

       }

       public String toString()

       {

              return "name is "+name+" number is "+num;

       }

       public int compareTo(Object o)

       {

              Student ss=(Student)o;

//            return num>ss.num?1:(num==ss.num?0:-1);//一次排序

    int result =num>ss.num?1:(num==ss.num?0:-1);//二次排序

    if(0==result)

    {

           result=name.compareTo(ss.name);

    }

    return result;

       }

}

7.       封装类

由基本数据类型得到如：

int a=3;

Integer in=new Integer(a);//构造方法

int j=in.inValue();

8.       Class类

在Java中，每一个类都有一个相应的Class对象，也就是说，当我们编写一个类，编译完成之后，在生成的.class文件中就会产生一个Class对象，用于表示这个类的类型信息。

获取Class实例的三种方式：

1）  利用对象调用getClass()方法获取该对象的Class对象

2）  利用Class类的静态方法forName()，用类的名字获取一个Class实例。

3）  运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以采用.TYPE的方式来获取相应的数据类型的Class实例。

class ClassTest

{

public static void main(String []args)

{

        Point pt=new Point();

        Class c1=pt.getClass();

        System.out.println(c1.getName());

        try

        {    

             Class c2=Class.forName("Point");

             System.out.println(c2.getName());

        }

        catch(Exception e)

        {

               e.printStackTrace();

        }

       

        Class c3=int.class;

        System.out.println(c3.getName());

       

        Class c4=Integer.TYPE;

        System.out.println(c4.getName());

       

        Class c5=Point.class;

        System.out.println(c5.getName());

       

        Class c6=Integer.class;

        System.out.println(c6.getName());//输出java.lang.Integer

}

}

class Point

{

int x,y;

}

在运行期间，如果我们要产生某个类的对象，Java虚拟机会检查该类型的Class对象是否已经被加载，如果没有被加载，JVM会根据类的名称找到.class文件并加载它，一旦某个类的Class对象被加载到内存，就可以用它来产生该类型的所有对象。

newInstance()调用类中缺省的构造方法，产生一个类的实例。

9.       Runtime类和Process类

每一个Java程序都有一个Runtime类的单一实例。通过Runtime.getRuntiem()获取Runtime类的实例。Runtime类是使用单利模式的一个例子。

Process 类是抽象类，不能直接实例化。

class RuntimeTest

{

public static void main(String []args)

{

        Runtime rt=Runtime.getRuntime() ;

        System.out.println(rt.freeMemory());

        System.out.println(rt.totalMemory());

 

    try

    {

    rt.exec("notepad");//调用外部程序

    //rt.exec("javac ClassTest.java");

    }

    catch(Exception e)

    {

    e.printStackTrace();

    }

}

}

Runtime类是是使用单例模式的一个例子。

单利模式：1）一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类

          2）单利类的一个最重要的特点是类的构造方法是私有的，从而避免了外部利用构造方法直接创建多个实例。

 单例类的实现

class Singleton

{

                        private statci final Singleton st=new Singleton();

                        private Singleton(){}

                        public static Singleton getInstance()

                        {

                             return st;

                        }

}//类似Runtime类中的方法。