java概念简析

 

[对象的创建与使用]

java中对象是由类创建出来的

创建对象包括：1.定义对象

              2.建立对象

                     3.初始化对象

       如:Rectangle myRectangle=new Rectangle(0,0,10,20);

使用：    1.通过对象变量的引用来使用对象

       如：myRectangle.width=20;

                     2.通过调用对象的方法来使用对象

       如：myRectangle.move(5,10);

[类，类的属性，类的成员变量]

类分类的说明和类体

如：class Point{

       int x,y; //变量说明

       x()  //类class中的一个方法x()

       {

       return x

       }

}           

      

       类的属性包括：

              1.指出此类的父类 (extends 部分)

              2.指出类提供的接口    (implements 部分)

       如：class ImNumber extends Number implements Collection(){

       ...

       }

              3.指出类的特性           (修饰部分)

       如：final class ImNumber extends Number implements Collection() {...}        //final 指出类ImNumber是个最终类

       又如：abstract class ImNumber extends Number implements Collection()

{...}        //abstract 指出类ImNumber是个抽象类

       final和abstract不可能同时出现

       由类创建出对象，而多个类组成包，同一个包中的类可以相互访问。

       但有种类是公共类，可以被包以外的其他类或对象访问。

用public表示是公共类，用private表示只能被同一个包中的其他类访问。用public和private表明类的一种访问权限。

       因此，类的说明是如下形式：

[modifiers]class ClassName [extends SuperClassName][implements Interfacelist(接口列表)] {

...} //带方括号的部分为可选的

类的成员变量定义包含：

       1.变量的访问权限 (用关键字public,private,protected或private protected表示)

       2.是否为静态变量 (用关键字static表示)

       3.是否为常量        (如果一个变量是一个常量，用关键字final)

              如：final int CON=20;

类的成员变量的访问权限：

       1.公用(public)变量       (允许所有的类访问)

       2.专用(private)变量      (只能被其所属的类访问)

       3.保护型(protected)变量      (允许被其归属的类，由此类派生的子类以及同一包中的其他类访问)

       4.专用保护型(private protected)变量 (允许被其归属的类，由此类派生的子类访问)

       5.默认型变量(不用任何词来修饰，没有设置访问权限。允许所归属的类访问和被同一包中的其他类访问)

[方法]

方法和类的结构相似，有方法说明和方法体。

       方法的结构表示如下所示：

[modifiers(访问权限)]type(返回参数类型，没有返回参数就写成void) methodName(para1,para2,... (入口参数)){

       methodBody

}

       例：       public int selMax(int x,int y){

if (x>y) return x;

else return y;

       }

}

[构造方法]

       不能有独立的方法名字，而且只能有入口参数，没有返回值。（名字与class一样，入口参数可不一样。）不能有abstract.

调用时，第一条用super()语句调用，（如果没用super(),系统默认为super()）有入口参数的必须要写出。

       如果第一条用this()语句调用，java系统就不会再默认这个构造方法调用父类。

[main方法]

       Applet中一定没有main方法，Application中一定包含main方法。main方法是static 类型的，也没有返回参数。

[变量隐藏和方法置换]

       在子类继承父类时，如果子类的成员变量和父类的成员变量同名，子类就隐藏了(override)父类的成员变量。此时，子类使用的是他自己的变量。

       如子类的方法与父类同名，同返回值，同入口参数，此时，子类的方法便置换了父类的方法。如想使用父类，需用super来实现。

[抽象类与抽象方法]

       抽象类不能创建对象，只能由其派生子类，是专门用来作为其他类的父类的。(abstract class xx{})

       抽象方法是只给出定义，但没有实现语句的方法。它的实现必须由子类来完成。

       注意：1.构造方法不能冠以abstract

       2.凡是定义为static或private型的方法不能再加abstract

       3.如果父类中已有同名的abstract方法，那么，子类中就不能再有同名的抽象方法

       4.抽象类中不一定有抽象方法，但包含抽象方法的类必须为抽象类。

[最终类，最终方法和最终变量]

       最终类不能再派生出子类，也就提高了安全性，程序可读性。

用关键字final。如final class ...{}

[接口]

       特点: 1.接口用关键字interface,不用class

              2.接口中定义的变量是最终的静态变量

              3.接口中没有自身的构造方法，而且定义的其他方法全是抽象方法，即只提供反方法的定义，没有提供实现方法的语句。

              4.接口采用多重继承机制，而不是采用单一的继承体制。

因为java的类中是采用的单一的继承体制，即一个类只有一个父类。在程序设计中，存在需要多重继承的时候，因此，java引入接口的概念。这样既保留了类的单一继承带来的程序简洁和层次清晰等优点，又可以使用多重继承来实现java的更方便，更强大的功能。

       接口支持多重继承，所以一个接口可以有好几个父接口，用逗号将几个父接口名分开，如：

       public interface Cookable extends Foodable,Printable{

       .....

}

       接口名通常第一个字母用大写，并用able或ible作结尾，表示接口能完成一定的功能。

       接口中定义的常量要用大写表示，全部默认为final和static型。

       接口中都用抽象方法，所以，接口中的方法定义中没有方法体，都默认为abstract属性。

如：       interface Bigable{

       int SUM=100;

       void increment();

       int setData();

}

[一个类调用有多个父接口的子接口所遵循的规则]

如：有First,Second,Three和Fourth的四个接口，而且，Three和Fourth是从First和Second继承来的。

       interface First{...}

       interface Second{...}

       interface Three extends First{...}

       interface Fourth extends First,Second{...}

此时，如有一个类Fifth用如下语句调用和继承Fourth接口：

       class Fifth implements Fourth {...}

那么，在Fifth中，不但要实现接口Fourth中所定义的所有方法，而且还要实现Fourth的父接口First和Second中所定义的所有方法。且要实现时，要使方法的名字，返回值，入口参数一一对应。

[线程的状态、线程的方法、线程的创建]

       线程由java.lang软件包提供,一个进程中可创建多个线程，且创建时不需要再分配数据段。

线程的生命周期：

分4个状态：

1．创建（new）状态

2．可运行（runnable）状态

3．不可运行（not runnable）状态

4．消亡（dead）状态

线程4个状态的转换：

1．创建（new）状态

两种操作：

一.   启动（start），使其进入可运行状态。

二.终止（stop），使其进入消亡状态。

如：Thread myThread=new MyThreadClass();         

2．可运行（runnable）状态

有如下操作：1.挂起（suspend）               2.睡眠(sleep) 3.等待(wait)   4.退让(yield) 5.终止(stop)

1~3使可运行状态的线程进入不可运行状态。

3．不可运行状态（not runnable）

有三种方式恢复到运行状态：

自动恢复

恢复（resume）操作

通知(notify或notify All)方法

4．消亡状态（dead）

线程的方法：

四大组：

1．构造方法（7个）

如：public Thread(); public Thread(Runnable target);…

2．实现线程行为的方法

就是run()方法，如：public void run();

3．改变线程状态的方法

就是如：启动、睡眠、终止、挂起、恢复、退让以及等待

如：public void start();          public static void sleep(long millis);     

public final void stop() 等

4．其他方法

有获取线程的名字getName、设置线程的名字setName等等

线程的创建：

有两种方法：

1．通过对Thread的继承来派生一个子类，再由此子类生成一个对象来实现线程的创建，这是比较简单直接的方法。

如:

import java.lang.*           //引用lang包

class Mango extends Thread {

        public void run(){                 //run方法置换父类Thread的run方法

…

}

}

还要由子类生成一个对象，并且进行启动操作，这样才能得到一个处于可运行状态的线程。生成对象其实就是完成线程的创建，启动则对已创建的线程进行操作。

语句如下：

Mango t=new Mango();

t.start();

线程其实也是一个对象。

2．通过一个类去继承接口Runnable来实现线程的创建，而这个类必须提供Runnable接口中定义的方法run()的实现。

如：下面的程序实现和接口的连接

public class xyz implements Runnable {

        int i;

public void run(){

        while (true){

System.out.println(“Hello”+i++);

}

}

}

然后再创建一个线程：

        Runnable r=new xyz();

        Thread t=new Thread(r);

这种比第一种灵活，由于java不支持多重继承，就需要用接口实现，可以按需要继承一个父类又可由此创建一个线程。

用第一种方法线程创建时，线程会自动执行子类的run()方法，不会执行Thread类的run()方法。因为Thread类中的run()方法是这样的：

       public void run()    {

if (target !=null){

target.run();

…

}

}

所以，Thread执行时，总是先检查线程的目标对象是否存在，如不为空，就执行目标对象的run()方法。子类中必须提供run()方法的实现。

用从Thread类派生子类的方法创建和启动线程时，会有如下两种方法：

1．派生子类，生成对象，再使用start方法

例： class First extends Thread{

              public void run(){

…

}

}

               First t=new First();

               t.start();

2．用一个语句完成生成对象和启动线程操作

例：class First extends Thread{

               public void run(){

               …

}

}

new First.start();

这里子类的名字和线程名字合二为一，都是First。

具体的例子：       

class FruitTes {

              public static void main(String arg[ ]) {

new Fruit(“Apple”).start();

new Fruit(“Orange”).start)();

}

}

       class Fruit extends Thread {

public Fruit(String ) {

super(str);

}

       public void run(){

for (int i=0;2;i++){

              System.out.println(i+“”+getName());

try{

       sleep((int)(Math.random()*500));

}

catch (InterruptedException e){}

}

}

}

程序先执行main方法，main方法里有两个语句，分别生成Fruit的两个对象即线程，并启动Apple和Orange两个线程。

用继承接口Runnable来创建线程：

public interface java.lang.Runnable{

              public abstract void run();

}

Runnable 只提供一个“接口”，实现线程具体行为的run()方法则必须由连接这个类提供。

用Runnable接口创建线程的方式：

1．采用构造方法

即在子类中先定义线程，然后在构造方法中完成线程的创建和启动。

       如：

              class Tigers extends Animal implements Runnable{

Thread mythread;

Tigers (String name){

mythread=new Thread(this);

mythread.start();

}

                     public void run(){

…} 

…    }

2．采用启动方法

即在程序中先定义线程，然后设计一个start()方法，在start()方法中再完成线程的创建和启动。

如：

        public class Clock extends Applet implements Runnable{

               Thread clockThread;

               public void start(){

if (clockThread==null){

clockThread=new Thread(this,”Clock”);

clockThread.start();

}

}

        public void run(){

               while (clockThread!=null){

…

}

}

}

[容器、组件与类]

容器中包含组件，也可包含其他容器。

容器和组件都要由java中对应的类创建实现。