线程间的通信
wait：告诉当前线程放弃监视器，进入睡眠状态直到其他线程进入同一监视器并调用notify为止
notify：唤醒同一对象监视器中调用wait的第一个线程。用于类似饭馆有一个空位后通知所有等待就餐的顾客中的第一位可以入座的情况
notifyAll：唤醒同一对象监视器中调用wait的所有线程，具有最高优先级的线程首先被唤醒并执行。用于类似某个不定期的培训班终于招生满额后，通知所有学员都来上课的情况
class Producer implements Runnable
{
       public void run()
       {
          Q q //定义一个缓冲区
           while (true)
           {  if(i==0)
                {
                  q.name="zhangsan";
                  q.sex="male"
                 }
                 else
                  {
                  q.name="LISI";
                  q.sex="female"
                   }
                   i= (i+1)%2
           }
         }
}
class Consumer implements Runnable
{    Q q
    public void run()
    {
  
       while (true)
         {
         }
     }

}
class Q
{
String name ="unknown"
String sex ="unknown"
}

多线程同步问题
*什么是线程安全
*同步代码块
*同步函数
*代码块与函数间的同步
*死锁问题
45分钟
刚才的程序有一个意外就是tickets的值
还有一种情况是tickets=0的情况时也会出现答应
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
    TestThread tt= new TestThread ()

new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();//接受tt对象，然后创建多个线程
     }
}
class TestTread  implments Runnable//集成接口 runnable类灵活的多
{   int tickets = 100;
   public void run()
    {
     while (true)
       {
        if (tichests>0)
{   try{Tread.sleep(10);}catch(Excetption e){}_
         system.out.println("run:"+Thread.currentThread().getName()+"is saling ticket"+ tickets
--)//
}
       }
     }
}
就打印除了0，-1，-2的情况
避免这种情况发生
保证if(tickets>0)
其他线程一定要保证一个线程中的System.println
一个程序中的只能允许一个线程可以执行的代码叫原子代码
只要将原子代码放在一个同步语句块中就可以，保证一个线程进入一个程序代码中
上面的程序中的原子代码是：
        if (tichests>0)
{   try{Tread.sleep(10);}catch(Excetption e){}_
         system.out.println("run:"+Thread.currentThread().getName()+"is saling ticket"+ tickets
--)
只要将它放在synchronized()
即：
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
    TestThread tt= new TestThread ()

new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();//接受tt对象，然后创建多个线程
     }
}
class TestTread  implments Runnable//集成接口 runnable类灵活的多
{   int tickets = 100;
    String str= new String("")
   public void run()
    {
     while (true)
       {
synchronized(str);//任意类型的对象,
{
        if (tichests>0)
{   try{Tread.sleep(10);}catch(Excetption e){}_
         system.out.println("run:"+Thread.currentThread().getName()+"is saling ticket"+ tickets
--)//
}
}
       }
     }
}

synchronized(str);//任意类型的对象,线程的标志为是0还是1，开始，对象的标志位是1，已进入代码，标志位制成0，如果又有一个线程进入代码，发现标志位0，就会让出cpu给其他线程，这样就保证了，只能有一个线程进入这个代码。当第一个线程执行完代码后，会把标志位制成1，变为1以后，其他线程就会进入代码块。
标志位也就是锁起位，即监视器
同步，是以牺牲系统的性能为代价的。如果程序没有线程安全问题，尽量不要用多线程。
如果把  String str= new String("")放在run()方法中就会出现不安全现象，也会打印出0,-1,-2
因为每一个线程检查的监视器不是同一个，所以就会有问题
多个线程要同步，他们使用的对象一定是同一个监视器。
还可以用同步函数来实现多线程
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
    TestThread tt= new TestThread ()

new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();//接受tt对象，然后创建多个线程
     }
}
class TestTread  implments Runnable
{   int tickets = 100;
    String str= new String("")
   public void run()
    {
          while (true)
         {
           sale();
         }
     }
   public void sale()
   {
         if (tichests>0)
      {   try{Tread.sleep(10);}catch(Excetption e){}_
         system.out.println("run:"+Thread.currentThread().getName()+"is saling ticket"+ tickets
--)//
       }
   }
}
这个线程不能实现同步的
如果在函数前加一个 sychronized 关键字
即   public sychronized  void sale()
就可以实现同步，如果一个方法前增加了关键字sychronized 只能有一个线程进入这个方法，其他的线程不允许进入这个方法。
sale方法使用的什么标志位？同步对象是this
代码块，函数来实现同步

线程启动的内部机制
start()不是cpu马上就执行这个线程。只是线程准备到就绪状态，如果cpu还在原来的线程上执行，将还在继续。
try{Thread.sleep(1);}catch(Exception e){}

方法中的监视器就是this
如果一个方法和代码块进行同步，可以在代码块中增加this这样就可以达到同步的作用
即synchronized(this)

死锁的问题：
一个线程进入x监视器，另一个线程进入Y监视器，y又等x，x又等待y

三、后台线程和联合线程
*如果我们对某个线程对象在启用（调用start方法）之前调用了setDaemon(true)方法，这个线程就变成了后台线程
*对java程序来说，只要还有一个前台线程运行，这个进程就不会结束，如果一个进程中只有后台线程运行，这个进程就会结束。
*pp.join()的作用是把pp所对应的线程合并到调用pp.jion();语句的线程中（主线程）
后台例子：
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
      Tread tt=new TestTread();
tt.setDaemon(true);
tt.start();
    
     }
}
class TestTread  extend Thread//不同
{
   public void run()
    {
     while (true)
       {
         system.out.println("run:"+Thread.currentThread().getName())//
       }
     }
}
联合例子：
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
      Tread tt=new TestTread();

tt.start();
int index=0;
  while (true)
       {
        if(index++==100)
         try{tt.join();}catch{Exception e} //异常处理，主线程和子线程合并 
         //try{tt.join(10000);}catch{Exception e} //异常处理，主线程和子线程合并  10秒
 system.out.println("main:"+Thread.currentThread().getName())//
   
     }
}
class TestTread  extend Thread//不同
{
   public void run()
    {
     while (true)
       {
   
         system.out.println("run:"+Thread.currentThread().getName())//
       }
     }
}

runnable

class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
      Thread tt=new Thread(new TestThead());接口对象

tt.start();//不再调用thread 中的run()方法，而是调用runnable接口对象的方法
int index=0;
  while (true)
       {
        if(index++==100)
         try{tt.join();}catch{Exception e} //异常处理，主线程和子线程合并 
         //try{tt.join(10000);}catch{Exception e} //异常处理，主线程和子线程合并  10秒
 system.out.println("main:"+Thread.currentThread().getName())//
   
     }
}
class TestTread  implments Runnable//集成接口 runnable类
{
   public void run()
    {
     while (true)
       {
   
         system.out.println("run:"+Thread.currentThread().getName())//
       }
     }
}

直接用runnable接口实现的线程和直接用Thread对象的线程有什么区别？
调用runnable接口的start方法，就不去调用thread的start方法

售票：
线程表示售票
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
    new TestThread ().start();
    new TestThread ().start();
    new TestThread ().start();
    new TestThread ().start();
     }
}
class TestTread  extends Thread//集成接口 runnable类
{   int tickets = 100;
   public void run()
    {
     while (true)
       {
        if (tichests>0)
         system.out.println("run:"+Thread.currentThread().getName()+"is saling ticket"+ tickets
--)//
       }
     }
}

四个售票点是各自买各自的票，四个对象都有自己的100张票
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
    TestThread tt= new TestThread ();
    tt.start();
    tt.start();
    tt.start();
    ttstart();
     }
}
class TestTread extends Thread//集成接口 runnable类
{   int tickets = 100;
   public void run()
    {
     while (true)
       {
        if (tichests)
         system.out.println("run:"+Thread.currentThread().getName()+"is saling ticket"+ tickets
--)//
       }
     }
}
只产生一个对象，只有100张票，启动了4个start，但是代码中只启动了一个线程来启动了start方法
来买票,不能说启动多了start就会启动多个线程。要实现铁路售票，需要
创建一个资源对象，要创建多个线程，我们需要把子对象实现接口Runnable
多个线程处理一个资源对象就需要用接口Runnable
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
    TestThread tt= new TestThread ()

new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();//接受tt对象，然后创建多个线程
     }
}
class TestTread  implments Runnable//集成接口 runnable类灵活的多
{   int tickets = 100;
   public void run()
    {
     while (true)
       {
        if (tichests)
         system.out.println("run:"+Thread.currentThread().getName()+"is saling ticket"+ tickets
--)//
       }
     }
}
使用Runnable接口创建多线程
*适合多了相同程序代码的线程去处理统一资源的情况，把虚拟cpu（线程）同程序的代码、数据有效分离
较好地体现了面向对象的设计思想
×可以避免由于Java单继承特性带来的局限。我们经常碰到这样一种情况。即当我们要将已经继承了某个类的子类放入多线程中。由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable
*当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。
*事实上，几乎所有多线程应用都可用Runnable接口方式

今天老公去面试，在面试之前只准备了两天的时间看书，不管怎么样吧，面试也是一次学习的机会，能有一次机会和那些高水平的人交流也算是一次提高自己的机会呀，老公加油！我永远支持你。

今天回家后，给我讲述了一下他面试的经过，让他做了4套题，总体感觉还是不错，但是毕竟还是有一些差距的，我鼓励老公，希望老公通过这次面试，能有一些感悟，知道平常应该多学习学习，他平常很少学习，倒是每次都鼓励我学习，就是自己不知道学习，恩，希望这次面试给他提个醒吧：），我永远是老公的后盾，嘿嘿。

第五课
进程和线程
lesson.java

class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
      new TestTread().run();
     while(true)
      {
         system.out.println("main()"+Thread.currentThread().getName());//thread类静态方法，
返回一个线程类的对象,得到这个线程的名称
       }
     }
}
class TestTread 
{
   public void run()
    {
     while (true)
       {
         system.out.println("run:"+Thread.currentThread().getName());//thread类静态方法，
返回一个线程类的对象,得到这个线程的名称
       }
     }
}

执行后，run方法是无限循环，所以main后面的代码没有执行，这是单线程的
如果想实现多线程
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
      new Thread().start();启用一个线程，开始执行他的程序代码及run()程序中的代码，但是Thread中的run()方法是一个空的函数没有任何意义，所以要编写一个子类覆盖他的run()方法；
      new TestTread().start();//不同，调用Thread的start()方法启用线程开始执行他的程序代码；
     while(true)
      {
         system.out.println("main()"+Thread.currentThread().getName())//thread类静态方法，
返回一个线程类的对象,得到这个线程的名称
       }
     }
}
class TestTread  extend Thread//不同
{
   public void run()
    {
     while (true)
       {
         system.out.println("run:"+Thread.currentThread().getName())//thread类静态方法，
返回一个线程类的对象,得到这个线程的名称
       }
     }
}

二、用Thread类创建线程

*要将一段代码在一个新的线程上运行，该代码应该在一个类的run函数中，并且run函数所在的类是Thread类的子类，倒过来看，我们要实现多线程，必须编写一个继承了Tread类的子类，子类要覆盖Thread类中的run函数，在子类的run函数中调用想在新线程上运行的程序代码。

*启动一个新的线程，我们不是直接调用Thread的子类对象的run方法，而是调用Thread子类对象的start（从Thread类的继承到的）方法，Thread类对象的start方法将产生一个新的线程，并在该线程上运行该Thread类对象中的run方法，根据面向对象的运行时的多态性，在该线程上实际运行的是Thread子类（也就是我们写的那个类）对象的run方法

*由于线程的代码段在run方法中，那么该方法执行完成以后线程也就是相应的结束了，因而我们可以通过控制run方法中的循环的条件控制线程的结束。

三、后台线程和联合线程
*如果我们对某个线程对象在启用（调用start方法）之前调用了setDaemon(true)方法，这个线程就变成了后台线程
*对java程序来说，只要还有一个前台线程运行，这个进程就不会结束，如果一个进程中只有后台线程运行，这个进程就会结束。
*pp.join()的作用是吧pp所对应的线程合并到调用pp.jion();语句的线程中
后台例子：
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
      Tread tt=new TestTread();
tt.setDaemon(true);
tt.start();
    
     }
}
class TestTread  extend Thread//不同
{
   public void run()
    {
     while (true)
       {
         system.out.println("run:"+Thread.currentThread().getName())//
       }
     }
}
联合例子：
class Threaddemo1
{
public static viod main(String [] args//main方法是在线程上进行的
    {
      Tread tt=new TestTread();

tt.start();
int index=0;
    
     }
}
class TestTread  extend Thread//不同
{
   public void run()
    {
     while (true)
       {
        if(index++==100)
         try{tt.join();}catch{Exception e}
         system.out.println("run:"+Thread.currentThread().getName())//
       }
     }
}

最近工作太忙，很少来更新日志，自己的学习计划也被打乱了，一直没有学习java了，现在公司项目太多，测试人员少，导致每天工作很忙，还经常加班，嗨！自己做了一个初步计划。

1.如果没有特别事情每天要看1-2个小时的书。
2.java也要按计划的学习。
3.考一个项目管理的职称。未来一年的计划（很难实现呀，主要是没有时间学习）
4.我的一个计划了解项目的数据库架构。学习学习，以便更快的了解自己负责的项目。

这是未来的几个计划，尽量吧，大家监督我哦，如果日志上没有内容，那就是说明我没有在学习：）

CEStorageClientImpl::AsyncRequestHandler 加载类型库/DLL 时出错

43分钟
1.package语句及应用
2.package语句作为java源文件的第一条语句，如果没有package语句，则缺省默认无名包
package test.lesson
运行java时要
java 包名.java名

要提前把包的文件夹创建好目录结构 test\lesson

也可以不提前创建好，只要在运行javac时加上-d . 就可以自动创建目录结构
例如 javac -d . lesson33.java就可以
-d编译的结果放在目录下，.表示当前目录。

做的Flash 终于做完了，发布到了公司的项目移名网的页面上了，通过这次，使自己记起了几年前学习过flash一些知识，几年不用的东西，现在都忘了，看来有些知识是需要笔头来记录的，也借助自己的博客，把自己的学习和工作经历记录下来，等以后再看自己的博客，会有另一种感觉的：）

1.异常定义了程序中遇到的致命的错误，而不是编译时的语句错误，
当程序发生异常，则程序中就会生成一个异常的对象传递给catch
2.try，catch语句
 try{
   new Test().devide(3.0);
   }
   catch(Exceptong e)//e 是异常的对象
   {
   System.out println(e.getMessage())
   }
当程序发生异常，则程序中就会生成一个异常的对象传递给catch
3.throws关键字
class Test
{
     public int devide(int x,int y) throws exception
  {
  int result =x/y;
  return result
  }
  
}

class TestException()
{
     public static void main(String[] arg)
  {
      try{
   new Test().devide(3.0);
   }
   catch(Exceptong e)
   {
   System.out println(e.getMessage())
   }
   system.out println("program is running here!")
  }
}
如果类Test有throws 则TestException 中必须有try--catch语句
或者：

class Test
{
     public int devide(int x,int y) throws exception
  {
  int result =x/y;
  return result
  }
  
}

class TestException()
{
     public static void main(String[] arg) throws Exception
  {
   new Test().devide(3.0);
   system.out println("program is running here!")
  }
}
但是实际编程中不要用这种方式要用 try catch语句

4.自定义异常与Throw关键字
自定义的异常类要继承Exception类
class Test
{
     public int devide(int x,int y) throws exception
  {
   if(y<0)
    throw new DevideByMinusException("Devisor is"+ y)//throw 抛出异常
  int result =x/y;
  return result
  }
  
}
class DevideByMinusException extends Exception
{
     public DevideByMinusException(String msg)
     {
    super(msg);
  }
}//自定义的类

class TestException()
{
     public static void main(String[] arg)
  {
      try{
   new Test().devide(3.-1);
   }
   catch(Exceptong e)
   {
   System.out println(e.getMessage())
   }
   system.out println("program is running here!")
  }

5.多个异常作处理
public int devide(int x,int y) throws ArithmeticException，DevideByMinusException
  //抛出多个异常，ArithmeticException，是算数异常

 try{
   new Test().devide(3.-1);
   }
   catch(Exception e)
   {
   }
   catch（ArithmeticException ex）
   {
       System.out println(("Devisor is running));
       ex.printStackTrace();//直接把异常打印到屏幕上
   }
   catch（DevideByMinusException e）
   {
       System.out println(("Devisor is"+ y));
     ex.printStackTrace();
   }
  注意：catch(Exception e)
   {
   }

不能放在其他的catch语句的前面，必须放在最后
6.可以在一个方法中使用 try....catch语句throws语句来实现程序的跳转
用throw 抛出对象，用try....catch语句捕获，可以实现程序的跳转
   void fun()
   {
     try
  {
     if (x==0)
        throw new XxxException("xxx");
     else
        throw new YyyException("yyy");
  }
  catch(XxxException("xxx"));
  {
 
  }
   catch(YyyException("yy"));
  {
 
  }
   }
7.一个父类的方法被覆盖时，子类覆盖父类的方法必须扔出和父类相同的异常或者是抛出异常的子类。可以不抛出异常
8.如果父类扔出多个异常，那么重写（覆盖）方法必须扔出那些异常的一个子集，也就是说不能扔出新的异常
 
9.Exception 类的父类是Trowable
10.finally
try{
   new Test().devide(3.-1);
   }
  
   catch（ArithmeticException ex）
   {
       System.out println(("Devisor is running));
       ex.printStackTrace();//直接把异常打印到屏幕上
   }
   catch（DevideByMinusException e）
   {
       System.out println(("Devisor is"+ y));
     ex.printStackTrace();
   }
    catch(Exception e)
   {
   }
   finally//不管try中的代码是否有异常，finally中的代码都要执行
          //唯一不被执行的情况就是：在catch语句中增加了System.exit(0)[表示程序到此结束]语句
   {
        System.out println("finally/");
   }

1.java中可以定义一些不含方法体的方法，他的方法体的实现交给该类的子类更具自己的情况去实现，
这样的方法是抽象方法，包含抽象方法的类叫抽象类。

2.抽象类必须用abstract关键字来修饰，抽象方法必须用abstract关键字来修饰，
3.抽象类不能被实例化，也就是说不能用new关键字去产生对象。
4.抽象方法只需要声明，不需要实现
5.含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类也还是抽象类
6.抽象类可以没有abstract方法（可以有别的方法），但是一个类如果有abstract方法，那么这个类必须用abstract修饰。
7.抽象类目的：使所有子类有相同的名字的方法。
8.不是抽象类中的所有方法都是抽象方法

1.final类不能被继承，即不能有子类
2.方法被final修饰，则这个方法不能被重写，只能继承不能覆盖。如果再用static修饰，那就是类方法了，
可以直接被类调用。
3.成员变量是final ，则变量只能被赋值一次，不能再次赋值
public final String x="abc" //这样是可以的

但是不能public final String  x

-----

然后再赋值是不可以的。
要么就是在变量初始的时候就赋值，要么就是在构造方法里进行赋值，
在其他地方都不能对final的变量进行复制
4.如果一个final的变量存在，在一个构造函数中对final变量赋值，那就必须在所有的构造函数中对他赋值

5.如果不产生对象，直接使用变量我们需要定义变量
（public static final共同标记的常量，这个常量就成了全局的变量）

class Person
{
  public static final String x// 不产生对象直接通过类就可以访问的变量即 Person.x,但是必须啊
                                 在定义常量的时候对x进行初始化，但是就不能在构造行数中竞相初始化了
  public String name="unknown";
  public int age=-1;//如果一个变量被赋值为1，表示这个变量没有被初始化
  public Person()//构造方法
  {
  }
     public Person(String name,int age)//构造方法
     {
           this.name=name;
            this.age=age;
     }
     public void getinfo()
     {
         System.out.println("name="+name+",age="+age);
     }
}

6.final标记的变量（成员变量或局部变量）即成为常量，只能被赋值一次
7.Float.MAX_VALUE，float最大值
8.方法中定义的内置类只能访问该方法内的final类型的局部变量，用final定义的局部变量相当于
一个常量，他的生命周期超出了方法运行的生命周期，经一个形参定义成final也是可以，
但是这就限定了我们在方法中修改形式参数的值。

1.子类有和父类同名的函数，子类对象调用的函数就是子类中的函数
2.子类不能把覆盖父类的方法变得更弱。子类不能继承父类中的私有的方法。
2.如果子类有和父类同名的函数，但是子类对象又想调用父类的函数，可以用super来表示调用的父类的函数
如：super.getinfo();//表示调用的父类的getinfo()
class Student extends Person //没有构造方法
 {
     public String school="unkown";
  public Student()
  {
   super();
     }
    public Student(String name,int age,)
 {
   super(name,age);
 }
     public Student(String name,int age,String school)
 {
   //super(name,age);
   this(name,age);//调用的是第二个构造函数
   this.school= school;
   super.getinfo();//表示调用的父类的getinfo()
函数 }
  public void getinfo()
     {
         System.out.println("school="+school+"name="+name+",age="+age);
     }
     public void study()
          {
          }   
}

class Person
{
     public String name="unknown";
  public int age=-1;//如果一个变量被赋值为1，表示这个变量没有被初始化
  public Person()//构造方法
  {
  }
     public Person(String name,int age)//构造方法
     {
           this.name=name;
            this.age=age;
     }
     public void getinfo()
     {
         System.out.println("name="+name+",age="+age);
     }
}

class Student extends Person //没有构造方法
 {
     public String school="unkown";
  public Student()
  {
   super();
     }
    public Student(String name,int age,)
 {
   super(name,age);
 }
     public Student(String name,int age,String school)
 {
   //super(name,age);
   this(name,age);//调用的是第二个构造函数
   this.school= school;
 }
     public void study()
          {
          }   
}

class TestStudent
{
     public static void(String [] args)
      {
         Student st= new student("zhangsan",20,"清华大学");
         /*st.name="zhang";
                           st.age=12;*/
           st.getinfo();
     }
}

1.分配成员变量的存储空间并进行默认的初始化，就是用new关键字，
产生对象后，对类中的成员变量按第三章的表的对应关系对对象中的成员
变量进行初始化赋值。
2.绑定构造方法参数，就是new Person(实际参数列表)中所传递进的参数赋值给构造方法中
的形式参数变量
  Student st= new student("zhangsan",20,"清华大学")
3.在执行构造方法之前，检查构造函数中看有没有this()函数（调用其他的构造方法的函数），如有this()调用，则调用相应的重载构造方法(被调用的重载构造方法又从步骤2开始执行流程),
被调用的重载构造方法的执行流程结束后，回到当前构造方法，当前构造方法直接跳转到步骤6（程序代码不包括super()和this()这样的语句的）
4.如果没有this()这样的函数，就显示或隐式追溯（super()隐藏或显示的意思）调用父类的构造方法(一直到Object类为止，Object是所有java类的最顶层父类，在本章后面部分有详细讲解)，父类的构造方法又从步骤2开始对父类执行这些
流程，父类的构造方法的执行流程结束后，回到当前构造方法，当前构造方法继续往下执行。
5.进行实例变量的显式初始化操作，也就是执行在定义成员变量时对所进行赋值的语句，如：
public String school="unkown";
6.执行当前构造方法的方法体重的程序代码。

1)为什么super() 和this()调用语句不能同时在一个构造函数里出现？
有了this（）再有super（）就没有意义了
2)为什么super() 和this()调用语句只能作为构造函数中的第一句出现？

1. 通过继承可以简化类得定义
2. java只支持单继承，不允许多重继承。(不能同时继承多个类)
3. 可以有多层继承，即一个类可以继承某一个类的子类
   如B继承了A，类C又可以继承B，那么类C也间接继承了A。
4. 子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。 
 在子类的构造方法中可以使用super（参数列表）调用父类的构造方法
不继承父类中private的成员变量和方法
5. 如果子类的构造方法中没有显示调用父类构造方法，也没有使用this关键字调用重载的其他构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法。
子类是必须要调用父类的构造函数的，
class Person
{
pulic String name;pulic int age;
pulic Person(String name,int age)//构造方法
  {
   this.name=name;
   this.age=age;
  }
public void getinfo()
 {
  System.out.println("name="+name+",age="+age);
  }
}

class Student extends Person //没有构造方法
{
pulic String school;
pulic void study()
  {
  }
}

class TestStudent
{
pulic static void(String [] args)
  {
   Student st= new student();
   st.name="zhang";
   st.age=12;
   st.getinfo();
  }
}

注明：
1).上面的程序执行时会提示错误，会提示子类找不到不带参数的Person构造函数，
如果一个应用程序中没有构造函数，则系统会自动增加一个不带参数的构造函数，
所以Student有一个默认的不带参数的构造函数。
在创建Student对象时，在调用student自身构造函数之前是需要先调用父类Person的不带参数的构造函数，
而Person中已经有带参数的构造函数，没有不带参数的构造函数，所以上面的程序运行时，编译器会报错。
2).针对这种情况，我们可以在Student类中的增加一个构造函数
public Student()
{
 super(”zhangsan",15)
}
在运行就不会出错的。
3).子类无论如何都需要调用父类的构造函数的。
4).使用super操作被隐藏的成员变量和方法，super.x和super.play()
5).this是调用全局变量，this()是调用其他的函数

6.如果一个类的生命中没有使用extends关键字，这个类被系统默认为是Object的子类，
Object是包java.lang中的类
7.成员变量的隐藏和方法的重写
当子类定义的成员变量和父类的成员变量同时，父类的成员变量不能被继承，
子类有和父类的方法一样的情况也不继承。
8.如果在子类中想使用被子类隐藏的父类的成员或方法就可以使用关键字super.
例如：super.x;super.play()
子类如果想调用父类的构造方法，必须在子类的构造方法中使用super，
并且必须是子类构造方法中的头条语句
super(父类构造方法中的变量)

class student extends Person
{

}

9.注意如果一个应用程序中没有构造函数，则系统会自动增加一个不带参数的构造函数
10.在定义类时，只要在父类中定义了有参数的构造函数，还要定义一个无参数的构造函数，因为它的子类中需要调用父类的构造函数
11.
class Person
{
pulic String name;pulic int age;
pulic Person(String name,int age)//构造方法
  {
   this.name=name;
   this.age=age;
  }
public void getinfo()
 {
  System.out.println("name="+name+",age="+age);
  }
}

class Student extends Person //没有构造方法
{
pulic String school;
pulic void study()
  {
  }
}

class TestStudent
{
pulic static void(String [] args)
  {
   Student st= new student();
   st.name="zhang";
   st.age=12;
   st.getinfo();
  }
}

1.java中并没有真正的多维数组，只有数组的数组，java中多维数组不一定是规则矩阵形式
2.定义一个多维数组
int[][] xx;
xx=new int[3][];
xx[0]=new int[3];
xx[1]=new int[2];

xx[2]就不能被使用，因为因为没有被指定为对象；

3.int[][] xx=new int[2][3];
xx[0][0]=3;
xx[1][2]=6;
for(int i=0;i<xx.length;i++)
{
for(int j=0;i<xx[i].length;j++)
System.out.println(xx[i][j])
}

4.定义数组时可以对数组进行初始化
int[][] xx={{3,2,7},{1,5},{6}}

5.与数序相关的函数
1）排序：用Array.sort来排序数组
int[] x;
x=new int[]{3,1,2,4}
java.util.Array.sort(x);//排序

2）使用System.arraycopy()函数拷贝数组
System.arraycopy(x,0,y,2,4)
5个参数：
x 源数组
0 开始copy的位置
y 目的数组
2 开始的位置
4 copy的长度