类和对象

最近复习了一下类和对象。

类

类中一般包括这几个部分：成员变量、成员方法、构造方法、主方法。

1.成员变量

类对象的属性又称为成员变量。

2.成员方法

类对象的行为又称为成员方法。

3.构造方法

特点：没有返回值且名称要与本类的名称相同。

作用：进行对象的创建，初始化成员变量。

每当实例化一个对象时，类都会自动调用构造方法。

4.主方法

定义了程序从何处开始，提供对程序流向的控制，可以在主方法里实例化一个对象。

主方法语法：

public static void main(String[] args){

方法体

}

主方法特性：静态（这样在没有创建对象时也能调用静态方法）、无返回值、形参为数组。

权限修饰符

private: 只能在本类中使用，在子类中是不可见的，对其他包的类也是不可见的。

public: 在本类、子类、其他包的类中都可以使用。

protected: 只能在本类、本包内的该类的子类或其他类使用。

注:  1.当声明类时不使用public、private、protected修饰符设置类的权限，则该类默认为protected型。

       2.类的权限设定会约束类成员的权限设定。

this关键字

this关键字用于引用对象的成员变量和成员方法。

在局部变量或方法参数覆盖了成员变量时，就要添加this关键字明确引用的是类成员还是局部变量或方法参数。

静态变量、常量与方法

static关键字：由static修饰的变量、常量、方法就称为静态变量、常量和方法。

被声明为static的变量、常量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用“类名.静态成员”调用。被static修饰相当于可以共享，静态成员可以直接被主方法调用。如：

public class Static {

    static doublePI=3.1415;       //定义静态常量

    static intid;                 //定义静态变量

 

    public static voidmethod1(){  //定义静态方法

        System.out.println(PI);    //调用静态常量

    }

 

    public voidmethod2(){          //定义非静态方法

        System.out.println(Static.PI);   

        System.out.println(Static.id);

        Static.method1();            //调用静态方法

    }

 

    public static voidmain(String[]args) {

        method1();                   //调用静态方法，这里不可以调用非静态方法method2，否则会报错。

    }

}

输出结果：

注 1.静态方法只能直接调用静态成员。

      2.非静态方法既能直接调用静态也能调用非静态成员。

      3.主方法中只能直接调用静态成员，因为主方法是静态的。若要在主方法中调用非静态成员，只能创建一个对象。

         4.静态方法中不可以使用this关键字。

对象

对象是类的实例，创建对象用new操作符：类名 对象=new 类名（）;

访问对象的属性与行为：对象.类成员

【实例】对象调用静态成员变量。

public classAccess {
    static int i=47;                   //定义静态成员变量
    public void call(){             //定义无返回值的成员方法
        for(i=0;i<3;i++){
            System.out.print(i+" ");
            if(i==2){
                System.out.println();
            }
        }
    }
    public Access(){               //构造方法

    }

    public static void main(String[]args) {            //主方法
        Access t1=new Access();                            //创建对象t1
        Access t2=new Access();                            //创建对象t2
        t2.i=60;                                                         //为t2的静态变量i赋值60
        System.out.println(t1.i);                               //输出t1的静态变量i
        t1.call();                                                        //t1调用成员方法
        System.out.println(t2.i);                               //输出t2的静态变量i
        t2.call();                                                        //t2调用成员方法
    }
}

输出结果：

第一行输出60的原因：i是静态的，即是共享的，其中一个对象为i赋值，那么其他对象调用i时也赋了值，调用的是同一个i。

第三行输出3的原因：因为上一步调用了成员方法，改变了i的值，循环的最后一步使i=3，且i是静态的，故第三行是3.

注： 若i不是静态的，那么t1和t2的i值互不影响。

【实例】编写一个类，定义一个修饰权限为private的成员变量，并定义两个成员方法，一个方法为此成员变量赋值，另一个方法获取这个成员变量的值，保证其他类继承该类时能获取该类的成员变量值。

public class love {
    private static int x;              //创建静态成员变量x，保证其他类继承该类时能获取该类的成员变量x。

    public int setx(int x) {           //定义成员方法为成员变量x赋值
        this.x = x;
        return 0;
    }
    public int getx(){                 //定义成员方法获取成员变量x的值
        System.out.println(this.x);
        return 0;
    }
    public love(){                     //定义构造方法

    }

    public static void main(String[] args) {
        love a=new love();              //创建对象a
        a.setx(100);                    //调用方法
        a.getx();
    }

}

输出结果:

【实例】编写一个矩形类，将长与宽作为矩形类的属性，在构造方法中将长、宽初始化，定义一个成员方法求此矩形的面积。

public class Square{
    private double x;
    private double y;
    public void setx(double x) {        //定义方法为x赋值
        this.x = x;
    }

    public double sety(double y){        //定义方法为y赋值
        this.y=y;
        return 0;
    }
    public double getx(){                 //获取x值
        System.out.println("长："+this.x);
        return 0;
    }
    public double gety(){                 //获取y值
        System.out.println("宽："+this.y);
        return 0;
    }
    public double method(){                //定义方法求面积
        double s;
        s=this.x*this.y;
        System.out.println("面积："+s);
        return 0;
    }
    public Square(){                        //定义构造方法
        this.x=0.0; 
        this.y=0.0;
    }

    public static void main(String[] args) {
        Square a=new Square();              //创建对象s
        a.setx(2.0);
        a.sety(3.0);
        a.getx();
        a.gety();
        a.method();

    }

}

输出结果：

完。