1.常用包：java.lang(lang包下的所有类都是隐式导入的) java.applet java.io java.awt java.net java.util
2.java中的八个基本数据类型：boolean,byte,short,int,long,char,float,double,其余的都是引用类型，如String
3.==和equals:==是判断引用的值（栈值）是否相等，equals是判断对象的内容（堆内容）是否相等。
一般的，如String str="abc",是先在栈中引用一个地址，然后在堆中赋一个str对象的内容“abc”。
class stringtest{
public static void main(String[] args){
String str1=new String("abc"); //String 是一个lang的类
String str2=new String("abc");
if(str1==str2){ //判断值是否相等
System.out.println("str1==str2");
}
else{
System.out.println("str1!=str2"); //打印出来的结果
}
if(str1.equals(str2)){ //注意equals的用法，判断对象内容是否相等
System.out.println("str1 equals str2"); //打印出来的结果
}
else{
System.out.println("str1 dont equals str2");
}
}
}
4.String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。例如：
String str = "abc";等效于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
上面的String str1=String("abc");如果换成了String str = "abc";，那么==的结果就是相等了。因为这里的String str = "abc";是赋值。==比较的也是值，所以是相等的。
5.String类是java中唯一可以和其他任何类型执行"+"和"+="的操作的类。如
int i=3;
char c='a';
String str="abc";
System.out.println(str+i+c); //打印出abc3a
6.StringBuffer:通常处理大量字符串。大小没有限制，也可以初始化的时候限定大小。StringBuffer(int index)。
StringBuffer不能用+和+=，它是用append来代替，并用toString来将结果转化为String类型。
int i=3;
char c='a';
String str="abc";
StringBuffer sb=new StringBuffer();
sb.append(str1).append(i).append(c);
System.out.println(sb.toString); //不打toString也可以，因为会自动。结果是一样的。
sb.delete(2,4); //delete是StringBuffer下的一个方法。用来删除指定的内容。这里就删除了从大于等于第2个字符到小于第4个字符之间的字符。打印出a3a
sb.insert(2,"hi"); //从第二个字符后面插入字符“hi”，打印出ahi3a
sb.reverse(); //逆序打印，打印出a3iha
//StringBuffer还有很多方法，就不一一例举了，具体看api文档。
7.int[] num=new int[3];
for(int i=0;i<num.length;i++){ //num.length代表的是数组的元素个数，不是内存长度
System.out.println(num[i]);
}
num=null; //通常将对象变为垃圾的时候，就赋值为null
8.参数值的互换
class change{
public static void ch(int x,int y){ //方法一
x=x+y;
y=x-y;
x=x-y;
}
public static void ch1(int x, int y){ //方法二
int z;
z=x;
x=y;
y=z;
}
}
9.基本数据类型的参数，在互换（或者说改变）之后，在main中调用的时候是不会改变的，但引用类型和数组类型是会的。
class change{
public static void ch(int x,int y){ //基本类型参数,结果为x=3,y=4
x=x+y;
y=x-y;
x=x-y;
}
public static void ch(int[] num){ //引用数组类型参数,结果为x=4,y=3
num[0]=num[0]+num[1];
num[1]=num[0]-num[1];
num[0]=num[0]-num[1];
}
public static void ch(Point pt){ //引用类型参数,结果为x=4,y=3
pt.a=pt.a+pt.b;
pt.b=pt.a-pt.b;
pt.a=pt.a-pt.b;
}
public static void main(String[] args){
int x=3,y=4;
ch(x,y);
System.out.println("x="+x+",y="+y);
int[] num=new int[]{3,4}; //注意数组直接赋值写法
ch(num);
System.out.println("c="+num[0]+",d="+num[1]);
Point pt=new Point();
pt.a=3;
pt.b=4;
ch(pt);
System.out.println("a="+pt.a+",b="+pt.b);
}
}
class Point{
int a,b;
}
10.在上面的Point中，它的System语句，我们如果直接System.out.println(pt); ,这样我们就会打出一些信息，如“类名@内存地址”。
如果我们想直接通过这样来打印结果，我们上面说过，System.out.println(pt);实际是System.out.println(pt.toString());,所以
我们就要通过在Point类中去覆盖toString()来打到目的。这是一个我们常用的手法，需要多加锻炼。
class Point{
int a,b;
public String toString(){ //覆盖
return "a="+a+",b="+b; //注意这里是a,b不是pt.a和pt.b
}
}
class change{
public static void ch(Point pt){
pt.a=pt.a+pt.b;
pt.b=pt.a-pt.b;
pt.a=pt.a-pt.b;
}
public static void main(String[] args){
Point pt=new Point();
pt.a=3;
pt.b=4;
ch(pt);
System.out.println(pt); //直接通过打印对象来得出结果
}
}
11.克隆：用来创建并返回此对象的一个副本，clone()方法，属于类Object。是protected Object 类型。如果要使得外部也能用这个副本，在派生类中必须要覆盖基类的clone()方法，在派生类中要声明为public，在派生类中调用的时候用super.clone()，在派生类中实现cloneable接口。cloneable接口没有抽象方法，是一个标志接口。只是要说明可以开始克隆了。
class student implements Cloneable{ //类这里必学继承自Cloneable接口
String name;
int age;
student(String name,int age){ //构造方法
this.name=name;
this.age=age;
}
public Object clone(){ //描述clone方法
Object o=null;
try{
o=super.clone(); //student的对象拷贝
}
catch(CloneNotSupportedException e){
System.out.println(e.toString());
}
return o;
}
}
class test{
public static void main(String[] agrs){
student s1=new student("为正",25);
student s2=(student)s1.clone(); //调用s1的一个clone，但要强制为student类型，因为clone是object类型。
s2.name="对待";
s2.age=20;
System.out.println("name:"+s1.name+" age:"+s1.age); //结果还是s1的结果，因为s2不是直接s1赋值的，而是克隆的。
}
}
12.引用类型的clone，跟上面的基本类型的是不一样，可以改变结果。因为引用类型即使克隆后与原来的对象也指向同一个地址，它变，原来的也变。对于Sting类型也是引用类型，但它是常量，所以不会改变原对象的值。
class professor{
String name;
int age;
professor(String name,int age){
this.name=name;
this.age=age;
}
}
class student implements Cloneable{ //类这里必学继承自Cloneable接口
String name; //String是特殊的引用类型，是常量，它引用的时候内存会再分配一块内存引用地址给他，所以不改变原来的值
int age;
professor p; //用引用类型的定义
student(String name,int age,professor p){ //加一个p
this.name=name;
this.age=age;
this.p=p;
}
public Object clone(){ //描述clone方法
Object o=null;
try{
o=super.clone();
}
catch(CloneNotSupportedException e){
System.out.println(e.toString());
}
return o;
}
}
class test{
public static void main(String[] agrs){
professor p=new professor("教授",50); //用professor来定义对象，不用student，这样可以用到下面的引用里。
student s1=new student("为正",25,p); //不用少了p
student s2=(student)s1.clone();
s2.p.name="对待"; //这里就改变了结果，打出的不是“教授50”，而是“对待20”
s2.p.age=20;
System.out.println("name:"+s1.p.name+" age:"+s1.p.age); //这里改为打印s1.p.name
}
}
13.死循环：while(true){}
14.换行：System.out.println();直接空着。或者System.out.println("name"+"\n"+"age");用转移字符"\n"，但这两种方式打印出来的上下之间的紧凑程度不一样。
