内容:
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类中的方法。