godlike

若脚步太慢 思绪会乱

遗忘是一种罪。

basic teach

[code="java"]public class Point {
    int x , y ;
    void output(){
        System.out.println(x);
        System.out.println(y);
    }
    public static void main(String[] args){
        Point pt;
        pt = new Point();
        pt.x = 10 ;
        pt.y = 20 ;
        pt.output();
    
    }
}[/code]

需求 : 编写一个驾驶汽车的方法 。

面向过程: 编写一个方法 drivecar() ;

面向对象: 将CAR看作一个对象 ,将CAR的共性抽取出来 ,设计一个CAR类,类中定义一个方法drive();,调用CAR.drive() ,实现需求 。


 * 类的构造方法 :
[code="java"]public class Point {
    int x , y ;
    Point(int a ,int b){  //构造方法 :构造方法的名称和类名是一样的 ,没有返回值。
        x=a;
        y=b;
    }
    void output(){
        System.out.println(x);
        System.out.println(y);
    }
    public static void main(String[] args){
        Point pt;
        pt = new Point(3,5);//在这里传参
        //pt.x = 10 ;
        //pt.y = 20 ;
        pt.output();
    
    }
}[/code]
1,构造方法的名字和类名一样,并且没有返回值。
2,构造方法只要用于类的对象定义初始化状态。
3,不能直接调用构造方法 ,必须new关键字,创建类的实例。
4,java类都要求有构造方法 ,如果没有定义构造方法,java编译器会自动为我们添加一个缺省的构造方法。
5,javap.exe---->反编译工具

new 关键字的理解
1,为对象分配内存空间。
2,引起对象构造方法的调用。
3,为对象返回一个引用 。

各种数据类型的默认值 :
1,数值型                0
2,boolean     false
3,char        '\0'
4,对象                         null    

方法的重载 overload :
条件 :方法的名称相同,但参数类型或者参数个数不同,才能构成方法的重载。

[code="java"]
public class Point {
    int x , y ;
    Point(int a ,int b){  //构造方法 :构造方法的名称和类名是一样的 ,没有返回值。
        x=a;
        y=b;
    }
    Point(){
    
    }
    void output(){
        System.out.println(x);
        System.out.println(y);
    }
    public static void main(String[] args){
        Point pt;
        pt = new Point(3,5);//这样会调用带有参数的构造方法
        pt = new Point();//这样会调用缺省无参的构造方法
        //pt.x = 10 ;
        //pt.y = 20 ;
        pt.output();
    
    }
}[/code]
特殊变量 this :
1,this变量代表对象本身。
2,当类中有两个同名变量,一个属于类的成员变量 ,一个属于方法里面的局部变量 ,使用this区分成员变量和局部变量。
3,使用this简化构造函数的调用。

实例方法和实例数据成员的说明 :
1,一个类所有的实例对象调用的成员方法在内存中只有一份拷贝,尽管在内存中有可能有多个对象,
    而数据成员在类的每个对象所在的内存中都存在一份拷贝。
2.this对象允许相同的实例方法为不同的对象工作。

当调用static静态方法时,可以直接调用类名.方法 :
[code="java"]public class Point {
    int x , y ;
    Point(int a ,int b){          x=a;
        y=b;
    }
    static void output(){
        
        System.out.println("静态方法");

    }
    public static void main(String[] args){
//        Point pt;
//        pt = new Point(3,5);//在这里传参
//        pt.x = 10 ;
//        pt.y = 20 ;
//        pt.output();
        Point.output(); //直接调用
        
    }
}[/code]


关键字 static :

1,静态方法只属于类的本身 ,称为类的方法 ,非静态方法可称为实例方法。
2,静态方法和静态变量是属于同一个类,而不属于类的对象。
3,静态方法和静态变量可以直接通过类名引用 。
4,在静态方法中不能访问非静态非静态方法和引用非静态成员,反之可以。
5,可以用类的对象obj去调用静态的方法method(),如obj.method().

常量的定义 :

1,例如 : static final double PI = 3.1415926 ;
2,作为一种约定 ,在定义常量时 ,一般采用大写形式 。
3,final常量可以在声明的同时赋予初值 ,也可以在构造函数中赋予初值。
4,为了节省内存 ,我们通常将常量声明为static 。

类的继承 :
  被继承的类称为超类(父类、基类) ,继承的类称为子类(派生类) 。java中不允许多继承。

方法的覆盖 : override
  在子类中定义一个与父类同名,返回类型,参数类型均相同的一个方法 ,称为方法的覆盖 。覆盖发生在子类与父类之间 。

特殊变量super :

1,特殊变量super提供了对父类的访问。
2,可以使用super访问父类被子类隐藏的变量或覆盖的方法 。
3,每个子类构造方法的第一条语句,都是隐含的调用super(),如果父类没有这种形式的构造方法 ,那么在编译的时候就会据报错 。

[code="java"]
class Animal{
    
    int height , weight ;
    
    void eat(){
        System.out.println("animal eat");
    }
    void sleep(){
        System.out.println("animal sleep");
    }
    void breathe(){
        System.out.println("animal breathe");
    }
}

class Fish extends Animal{
    void breathe(){
        super.breathe();//子类调用父类的方法 。
        System.out.println("fish breathe");
    }
}

class Integration{
    public static void main(String[]aargs){
        Animal an = new Animal();
        Fish fh = new Fish();
        
        an.breathe();
        fh.height= 22;
        fh.breathe();
    }
}
[/code]

多态性 :
通过覆盖父类的方法来实现 ,在运行时根据传递对象的引用 ,来调用相应的方法 。

例 :
需求 : 求长方形的周长和面积
1,面向过程的方法
[code="java"]class Rectangle{
    static int perimeter(int length ,int width)
    {
        return 2*(length+width);
    }
    static int area(int length,int width)
    {
        return length*width ;
    }
    
    
    
    
    public static void main(String[] args)
    {
        System.out.println(Rectangle.perimeter(2, 3));
        System.out.println(Rectangle.area(3,5));
    }
}[/code]
2,面向对象的方法
[code="java"]class Rectangle
{
    int l ,w ;
    
    int perimeter()
    {
        return 2*(l+w) ;
    }
    int area()
    {
        return l*w ;
    }
    public static void main(String[] args)
    {
        Rectangle rect1 = new Rectangle();
        Rectangle rect2 = new Rectangle();
        rect1.l = 10 ;
        rect1.w =  91;
        rect2.l = 2 ;
        rect2.w = 3 ;
        System.out.println(rect1.perimeter());
        System.out.println(rect1.area());
        System.out.println(rect2.perimeter());
        System.out.println(rect2.area());
    }
}[/code]


方法的使用控制  :
          public  protected    default   private
同类      1            1                1         1
同包      1            1                1 
子类      1            1
通用性   1

final 方法 :
    1,为了确保某个函数行为在继承过程中保持不变,并且不能被覆盖,可以使用final方法。
    2,为了效率上的考虑,将方法声明为final ,让编译器对此方法的调用进行优化,更注意的是 : 编译器会自行对final方法进行判断,并决定是否进行优化,通常在方法的体积很小,而我们确实不希望覆盖它时,才将他声明为final 。
    3,class中的private和static方法自然就是final 。

抽象方法和抽象类:
    1,在类中没有方法的方法就是抽象方法 。
    2,还有抽象方法的类 ,即为抽象类 。
    3,如果一个子类没有实现基类方法中所有抽象方法 ,则子类也为一个抽象类 。
    4,我们可以将一个没有任何抽象方法的类声明为abstract ,避免这个类产生任何的对象 。
    5,抽象类不能实例化对象 。
   

posted on 2011-12-19 14:39 CODLIKE 阅读(66) 评论(0)  编辑  收藏


只有注册用户登录后才能发表评论。


网站导航:
 
<2025年7月>
293012345
6789101112
13141516171819
20212223242526
272829303112
3456789

导航

统计

公告

@import url(http://www.blogjava.net/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css);

留言簿

文章档案

搜索

最新评论

godlike