Java复习4

封装，继承，多态

1.类的声明：
1）abstract或final：前者指出所定义的是抽象类，后者指出所定义的是最终类，不能被继承。
2）extends 父类名：指出所定义的类继承于哪一个父类，Java是单继承的，后面只能跟一个父类。

由类和方法的定义可知，在类和方法中均可定义属于自己的变量。类中定义的变量是成员变量，而方法中定义的变量是局部变量。类的成员变量与方法中的局部变量是有一定区别的。

（1）从语法形式上看，成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被public、private、static等修饰符所修饰，而局部变量则不能被访问控制修饰符及static所修饰；成员变量和局部变量都可以被final所修饰。
（2）从变量在内存中的存储方式上看，成员变量是对象的一部分，而对象是存在于堆内存的，而局部变量是存在于栈内存的。
（3）从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而产生，随着方法调用的结束而自动消失。
（4）成员变量如果没有被赋初值，则会自动以类型的默认值赋值（有一种情况例外，被final修饰但没有被static修饰的成员变量必须显式地赋值）；而局部变量则不会自动赋值，必须显式地赋值后才能使用。

1）方法的声明

• static:用static修饰的方法称为类方法，通过类名引用，即类名.方法名（参数列表）；没有被static修饰过的方法称为实例方法，通过对象引用，即对象名.方法名（参数列表）；
• final：说明所定义的方法不能覆盖。
• abstract：说明所定义的方法为抽象方法，此时方法不能有是实现体。

2）方法调用中的参数传递
在Java中，方法调用的参数（无论是基本数据类型还是引用类型的参数）都是值传递。

• 参数为基本数据类型：直接得到副本
• 参数为对象类型：传递对应变量的值，即某个对象的引用（实际占用的内存地址），如果方法内对该参数指向的对象进行了修改，这种修改对该对象是永久性的。（如果修改的是类变量的值，那么这种修改对该类的所有对象是永久性的）
• 参数为数组类型：和对象一样，传递数组的引用。如果方法内对该参引用的数组对象的元素进行了修改，这种修改是永久性的。（注：在将数组对象传入方法，进行数组元素修改时，要用数组名＋下标的形式直接引用数组元素进行修改。）二维数组转置矩阵如下：

public class App_1 {
    public static void main(String args[]) {
        int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int[][] b = new int[3][3];
        Trans A = new Trans();
        b = A.trans(a);
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                System.out.print(b[i][j] + " ");
            }
            System.out.println();
        }

    }
}
    class Trans {
        public  int[][] trans(int[][] array) {
            for (int i = 0; i < array.length; i++) {
                for (int j = 0 ; j < array[i].length; j++) {
                    int temp = array[i][j];
                    array[i][j] = array[j][i];
                    array[j][i] = temp;
                }
            }
            return array;
        }
    }

方法的参数列表不同。

• 1.特殊性：

（1）构造方法的方法名与类名相同；
（2）构造方法没有返回值，但不能写void
（3）构造方法的主要作用是完成对类对象的初始化工作；（4）构造方法一般不能由编程人员显式地直接调用，而是用new来调用；
（5）在创建一个类的对象的同时，系统会自动调用该类的构造方法为新对象初始化。
（6）构造方法的优先级一般比代码块低

• 2.默认构造方法
  （1）一旦用户为该类定义了构造方法，系统就不再提供默认的构造方法，这是Java的覆盖（overriding）所致。
  （2）若在一个类里只定义了有参数的构造方法，但却调用无参数的构造方法创建对象，则编译不能通过。
  （3）构造方法的重载
  （4）从一个构造方法调用另一个构造方法

public class App_2 {
    public static void main(String[] args) {
        Cylinder volu = new Cylinder();
    }
}

class Cylinder
{
    private double r;
    private int h;
    private double pi=3.14;
    String color;
    public Cylinder()
    {
        this(2.5, 5, "red");//用this来调用另一个构造方法
        System.out.println("无参构造方法被调用");
    }

    public Cylinder(double _r,int _h,String _str)
    {
        System.out.println("有参构造方法被调用");
        r = _r;
        h = _h;
        color=_str;
    }
}
//注：用this()调用其他构造方法时，它必须作为构造方法中的第一条语句。

• 对象的创建：类名 对象名；

• 对象实例化：变量名 = new 类名（参数列表）；
  此时，系统要做的工作：1.分配空间，将成员变量初始化为默认值，如整型变量为0，逻辑类型变量为false，引用类型变量为null。2.也可执行显式初始化，即执行类成员变量声明时带的赋值表达式。3.也可以通过相应的构造函数完成初始化。

• 对象的使用: 对象.成员变量/成员方法（参数列表）

static称为静态修饰符，它可以修饰类中的成员。被static修饰的成员称为静态成员，也称为类成员，而不用static修饰的成员称为实例成员。

• 1.实例成员：在类定义中如果成员变量或成员方法没有用static来修饰，则该成员就是实例成员。
• 2.静态变量(类变量）：

1）用static修饰的成员变量称为静态变量，也称为类变量。类变量被类的所有对象所共有，即任何一个对象修改了静态变量，那么其他对象访问的是该变量修改后的值。
2） 类中若含有静态变量，则静态变量必须独立于方法之外，就像其他高级语言在声明全局变量时必须在函数之外声明一样。
3） 静态变量不需要实例化就可以使用。当然，也可以通过实例对象来访问静态变量。使用格式有如下两种：

 类名.静态变量名;
 对象名.静态变量名;

• 3.静态方法（类方法）：

• 几重含义
  1）非static的方法是属于某个对象的方法，在创建这个对象时，对象的方法在内存中拥有属于自己专用的代码段。而static的方法是属于整个类的，它在内存中的代码段将被所有的对象所共用，而不被任何一个对象所专用。
  2）由于static方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员，而只能处理属于整个类的成员，即static方法只能访问static成员变量或调用static成员方法，或者说在静态方法中不能访问实例变量与实例方法。
  3）在静态方法中不能使用this或super。因为this是代表调用该方法的对象，但现在静态方法既然不需要对象来调用，this也自然不应存在于静态方法内部。
  4）调用静态方法时，可以使用类名直接调用，也可以用某一个具体的对象名来调用。其格式如下：

 类名.静态方法名();
 对象名.静态方法名();

5）现在有了静态方法的知识后，读者现在可以理解main（）方法的定义了。由于Java虚拟机需要在类外调用main（）方法，所以该方法的访问权限必须是public；又因为Java虚拟机运行时系统在开始执行一个程序前，并没有创建main（）方法所在类的一个实例对象，所以它只能通过类名来调用main（）方法作为程序的入口，即调用main（）方法的是类名，而不是由类所创建的对象，因而该方法必须是static的。

• 4.静态语句块（静态初始化器）
  1）静态初始化器是由关键字static修饰的一对花括号“{}”括起来的语句组。
  2）静态初始化器不是方法； 对类自身进行初始化；在所属的类被加载入内存时由系统调用执行；在类被加载入内存时只执行一次，与创建多少个对象无关；如果有多个静态初始化器，则它们在类的初始化时会依次执行。
  3）在对象生成前就分配了内存空间，先于对象的创建或对象成员变量的初始化。

1）对象的赋值和比较

//创建圆柱体类Cylinder，并对该类创建的对象进行赋值运算。
class Cylinder {
    //定义类Cylinder
    private static double pi = 3.14;
    private double radius;
    private int height;
    public Cylinder(double r, int h) {
        radius = r;
        height = h;
    }
    public void compare(Cylinder volu) //以对象作为方法 的参数
    {
        if (this == volu)//判断this与volu是否指向同一对象
            System.out.println("这两个对象相等");
        else
            System.out.println("这两个对象不相等");
    }
}
public class App_3 {
    public static void main(String[] args) {
        Cylinder volu1 = new Cylinder(1.0, 2);
        Cylinder volu2 = new Cylinder(1.0, 2);
        Cylinder volu3 = volu1;
        volu1.compare(volu2);//调用compare(),比较volul与volu2是否相等
        volu1.compare(volu3);//调用compare(),比较volul与volu3是否相等
    }
}
//注：引用变量volu1与volu2的值分别是这两个对象在内存中的首地址，显然它们是不相等的。而volu1和volu3是指向同一个对象的两个变量，它们的值是同一对象在内存中的首地址，所以它们是相等的。

2）引用变量作为方法的返回值

3）类类型的数组
以对象数组作为参数传递给方法，返回对象数组中最小的成员变量。

• package语句
  1）使用package语句来指出所定义的类属于某个特定的包，格式：package 包名；
  2）package语句必须放在程序中非注释代码的第一行；package语句只能有一个或没有；源程序没有package语句的，则源程序中所定义的类都属于默认包；

• import语句
  1）使用import语句来引入包成员：
  格式1：import 包名.类名；
  格式2：import 包名.*；
  使用包中的多个类时，可以使用通配符" * "，来引入包中的所有类。但“∗”只能表示本层次的所有类，不包括子层次下的类。
  2） import语句必须放在源程序任何类声明之前，但要在package语句之后；一个源程序可以有多个import语句。

• private：无法从该类的外部访问到该类内部的成员，而只能被该类自身访问和修改，而不能被任何其他类（包括该类的子类）获取或引用。
• friendly：类和类成员的默认修饰符，含义为只能被类本身和同一个包中的类所访问。
• protected：可以被类本身、该类的子类（无论是否在同一个包中）和同一个包中的类所访问。
• public：同一类，同一包，不同包中的子类，不同包中的非子类。

• Object类
  常用方法：
  1.public boolean equals(Object obj)
  “==”运算符用于比较两个变量本身的值，即两个对象在内存中的首地址，而equals（）方法则是比较两个字符串中所包含的内容是否相同；
• String类与StringBuffer类
• Math类
• Random类
• Date类
• Array类
  …待更新