java_lesson

1.JAVA有下标检查;
2.String s;  s为String类的一个引用(String s=new String("a string"));
  所有的对象都必须new出来;
3.所有方法都必须再类中;赋值实际上将句柄从一个地方复制到另一个地方;
  public class Test
{
 int i=0;
 public static void main(String[] args)
 {
  Test n1=new Test();
  Test n2=new Test();
  n1.i=10;
  n2.i=20;
  System.out.println("n1 = "+n1.i+"  n2 = "+n2.i);
  n1=n2;
  System.out.println("n1 = "+n1.i+"  n2 = "+n2.i);
  n2.i=30;
  System.out.println("n1 = "+n1.i+"  n2 = "+n2.i);
   }
 }
  类对象的赋值,引用复制,将两个对象引用相同地址;
 
  class Test
{
   char c;
}
public class PassObject
{
   static void fuction(Test t)
  {
  t.c='t';
  }
   public static void main(String[] args)
   {
  Test test = new Test();
  test.c='f';
  System.out.println(" the value of c:"+test.c);
  fuction(test);
  System.out.println(" the value of c:"+test.c);
   }
  }
  当对象做函数参数被调用时,引用被传递,
5.this可以为调用了其方法的那个对象生成返回自身的句柄;
  在一个构造函数中返回另一个构造函数时,用this; 
6.垃圾收集函数  finalize();与C++的析构函数不同;对象可能不会被当作垃圾被清理掉;垃圾只跟内存有关;
7.java中可以在定义数据成员时为其赋值;(c++只能在构造函数内)
  可以调用一个方法来进行初始化;(初始化的顺序是有变量定义的顺序决定的)
  变量在任何方法前得到初始化;
8.静态的东西属于类;静态数据成员只在这个类的第一个对象被创建的时候被初始化;
  class类:类对象(包含静态成员变量);
9.java程序编译过程:调用编译器_查找文件_装载内存_形成类对象_类静态成员初始化__创建new()分配足够空间_空间被清空为0,知道都得到缺省值;
  静态初始化块(相当于静态初始化语句,可以很早被执行)
 
  class Cups
  {
   static Cups c1;
   static Cups c2;
   static
   {
    c1 = new Cups(1);
    c2 = new Cups(2);
    }
   Cups()
   {System.out.println("Cups is created!");} 
   } 
   定义初始化块(在构造函数初始化前执行非静态数据成员)没有名字的类的构造函数
   public class Mugs
   {
    Mugs m1;
    Mugs m2;
    {
     m1 = new Mugs(1);
     m2 = new Mugs(2);
     System.out.println("m1 m2 is initialized!");
     }
        Mugs()
    {System.out.println("Mugs is initialized!");}
    }
10.数组:java数组不允许在定义数组时指定一个数组的大小(括号中不许有数字);
   数组变量实际上时指向一个数组的句柄;
   数组中的固定成员 length
   for(int i =0,i<Array.length,i++)
11.对象数组
   import java.util.*;
   public class ArrayClassObj
   {
    static Radam radam = new Radam();
    static int pRand(int mod)
    {
     return Math.abs(rand.nextInt())%mod;
     }
    public static void main(String[] args)
    {
     // a[i]为对象引用变量
     Integer[] a = new Integer(pRand(20));
     System.out.println("the length of a is "+a.length);
     for(int i = 0;i<a.length:i++)
       a[i]=new Integer(pRand(500));
       System.out.println("a["+i+"]"+a[i]);
     } 
    } 
12.访问控制:封闭
13.包:库单元  (命名空间的管理)
   用import来引入包或包里的成员  improt java.util.*(包中所有类);import java.util.Vector(Vector类);
14.编译单元(以java结尾的文件,可以有一个public类,名字和文件名同,一个单元仅有一个public类) ,每个类都生成一个class文件,一个包就是一堆.class文件,不是简单文件合并;
   package mypackage;
   public class MyClass;
   如果要使用MyClass,要么import 引入,要么使用全名;
 15.CLASSPATH:(环境变量)包文件必须放在包目录文件下;     
       如果声明package 则必须给出全名;
 16.类的访问属性:
    每个成员前都必须著名属性;缺省时friendly(包内有效)
    如果没有public,则文件名可以任意;

继承与多态性
1.格式: class thisClass extends SuperClass{class body}  (java只能做单继承) 
  eg:
  class Cleanser
{
   private String s = new String("Cleanser");
   public void append(String a){s +=a;}
   public void dilute(){append("dilute");}
   public void apply(){append("apply()");}
   public void scrub(){append("scrub");}
  public void print(){System.out.println(s);}
  public static void main(String[] args)
  {
   Cleanser x = new Cleanser();
   x.dilute();
   x.apply();
   x.scrub();
   }
}

public calss Detergent extends Cleanser
{
 public void scrub()
 {
  append("Detergen.scrub()");
    super.scrub();
  }
  public void foam(){append("foam()");}
  public staitc void main(String[] args)
  {
   Detergent x = new Detergent();
   x.dilute();
   x.apply();
   x.scrub();
   x.foam();
   x.print();
   System.out.println("Testing base class:");
   Cleanser.main(args);
   }
}
2.传递构造参数:
 构造子类对象时,父类的构造函数会被调用

继承
 (单继承)
 class Thisclass extends superclass{classbody;}
 初始化的顺序先父类再自身;
 super();/*调用父类的构造函数*/
 初始化和类的装载
  要创建子类的对象->分配空间->装载所在的类->检查是否有父类->装载父类->检查父类中的静态成员,对其初始化->检查子类的静态成员,对其初始化->初始化父类其它成员->初始化子类的成员;
 子类的方法覆盖父类的方法;