第4章 类与对象

一.类与对象的概念

1.抽象原则：舍弃研究对象个别非本质的特征，抽取共同本质的特征

目前主要强调过程抽象（动态成员方法）和数据抽象（描述数据数据成员）

属性：一组数据描述对象特征

 

2.描述一个类需要三个方面：

类标识：非重复类名

属性说明：描述静态特征

方法说明：描述动态特征

class Rectangle{
    //类的属性：静态特征
    int length;
    int width;
    //类的方法：动态特征
    int area(int l,int w){
        int length=l;
        int width=w;
        return(length*width);
    }
}

 

3.类与对象的关系

对象是类的一个实例，类是一个独立的程序单位，是对象的模板

定义对象前先定义类，在定义了类之后才可以定义对象

 

二。封装机制

1.在类的定义中设置访问对象属性及方法的权限，限制本类对象及其他类的对象使用的范围

提供一个接口来描述其他对象的使用方法

其他对象不能直接修改本对象所拥有的属性和方法

class 类名
{
    数据成员
    成员方法
}

更为严谨的定义

[类修饰符] class 类名 [extends 父类名] [implements 接口列表]
{
    数据成员
    成员方法
}

如果一个类前没有修饰符，则这个类只能被同一个包里的类使用。Java规定同一个程序中的所有类都在同一个包中。无修饰符的类可以被同一个程序文件中的类使用，但不能被其他程序文件中的类使用

Final类不能被继承

obstract是抽象类

class Pp1{
    int a=45;
}

public class C4_4 {
    public static void main(String[] args){
        Pp1 p1=new Pp1();
        System.out.println(p1.a);
    }
}

 

2.public修饰符

在一个程序文件中，只能定义一个public类，其余的类可以是无修饰符的类，也可以使用final修饰符定义的最终类

class Pp{
    C4_5 f1=new C4_5();
    int add(){
        return(f1.b+f1.c);
    }
}

public class C4_5 {
    int b=20,c=3;
    public static void main(String[] args){
        Pp p1=new Pp();
        System.out.println(p1.add());
    }
}

 

3.final修饰符

最终类是不能被任何其它类所继承

 

4.abstract修饰符

抽象类刻画了研究对象的公有行为特征，通过继承机制将这些特征传送给他的派生类

当一个类中出现了一个或多个用abstract修饰符定义的方法时，必须在这个类前面加上abstract修饰符，将其定义为抽象类

可以同时使用两个修饰符来修饰一个类

一个类可以被修饰为public abstract，也可以被修饰为public final，但不能被修饰为abstract final

 

三.数据成员

1.命名

开头：字母，$，下划线，开头不能用数字

访问权限修饰符：public private protected

非访问权限修饰符：static final

 

2.用static修饰的静态数据成员不属于任何一个类的具体对象，而是属于类的静态数据成员

他被保存在类的内存区的公共存储单元中，而不是某个对象的内存区，因此任何对象访问它时，存取到的都是相同的数值

可以通过类名加点操作符访问它

 

3.静态数据成员的初始化

静态初始化器用于对类的静态数据成员进行初始化，而构造方法用来对新创建的对象进行初始化

静态初始化器不是方法，没有方法名、返回值和参数表

静态初始化器是在他所属的类加载到内存时由系统调用执行的，而构造方法是系统用new运算符产生新对象时自动执行的

 

4.final修饰的最终数据成员

一个类的数据成员用final修饰符修饰，则这个数据成员就被限定为最终数据成员，最终数据成员可以在生命时进行初始化，也可以通过构造方法赋值，但不能在程序的其他部分赋值，它的值在程序的整个执行过程中不能改变

 

5.局部变量使用方法

public class C4_10 {
    public static void main(String[] args){
        int a=2,b=3;
        int f=add(a,b);
        System.out.println("f="+f);
    }
    static int add(int x,int y){
        int z,d;
        z=x+y;
        return z;
    }
}

 

7.形式参数与实际参数

实参可以是表达式

实参变量对形参变量的数据传递时值传递，只能由实参传给形参，而不能相反

public class C4_12 {
    static void add(double x,double y){
        double z;
        z=x+y;
        System.out.println("z="+z);
        x=x+3.2;
        y=y+1.2;
        System.out.println("x="+x+"\ty="+y);
    }
    static double add1(double y1,double y2){
        double z;
        z=y1+y2+2.9;
        return z;
    }
    public static void main(String[] args){
        int a=2,b=7;
        double f1=2,f2=4,f3;
        add(a,b);
        System.out.println("a="+a+"\tb="+b);
        f3=2+add1(f1,f2);
        System.out.println("f1="+f1+"\tf2="+f2+"\tf3="+f3);
    }
}

 

8.编程计算n!的值

import java.util.Scanner;

public class C4_14 {
    static int fac(int n){
        int fa;
        if(n==0){
            fa=1;
        }
        else{
            fa=n*fac(n-1);
        }
        return fa;
    }
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int f=fac(n);
        System.out.println(n+"!="+f);
    }
}

 

9.用static修饰的静态方法

static方法是属于整个类的

引用静态方法时可以使用与对象关联的引用变量名作为前缀

static方法只能访问static数据成员，不能访问非static数据成员，但非static方法可以访问static数据成员

static方法只能访问static方法，不能访问非static方法

static方法不能覆盖，这个类的子类不能有相同名及相同参数的方法

 

10.用final修饰的最终方法

子类可以利用重载机制修改父类继承的某些数据成员及方法

用final修饰符修饰的方法称为最终方法

class A1{
    final int add(int x,int y){
        return (x+y);
    }
    int mul(int a,int b){
        int z;
        z=add(1,7)+a*b;
        return z;
    }
}
public class C4_17 extends A1{
   public static void main(String[] args){
       int a=2,b=3,z1,z2;
       C4_17 p1=new C4_17();
       z1=p1.add(a,b);
       z2=p1.mul(a,b);
       System.out.println("z1="+z1);
       System.out.println("z2="+z2);
   }
}

 

11.用native修饰的本地方法

破坏可移植性

在Java程序中使用native方法时应该特别注意平台问题