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中对应的类创建实现。 
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值