java基础(三)：面向对象(上)

 

五、面向对象

 

5.1、类和对象

　　类的三个最常见成员：构造器、属性、方法；

　　属性修饰符：public（protected、private）、static、final

　　方法修饰符：public（protected、private）、static、final（abstract）

　　

　　1、静态成员和非静态成员

　　static 修饰的属性、方法称为静态属性、静态方法，属于类共有（类 和 实例 都可以调用，否则只能实例调用）。

　　静态成员（属于类共有，类调用时没有创建实例）不能直接访问非静态成员（非静态成员必须使用实例来调用，如main方法要new对象）；

 

　　2、对象的产生、引用和指针　　

　　Person p = new Person();

　　创建对象：通过new关键字调用Person类的构造器，返回一个Person实例（创建一个对象）并赋值给p变量；

　　JAVA除了8种基本数据类型，还有引用类型：类、数组、接口、null类型； 

　　上面代码产生两个实体：p变量、Person对象。因为类是引用数据类型，所以Person对象赋值给p变量时只是把对象的引用赋值给了p(存放在栈内存中)，真正的Person对象则是存放在堆内存中。

　　Person p2 = p; //p引用变量只存放了对象的引用地址，这里只是把p保存的地址赋给了p2

　　3、对象的this引用

　　this关键字总是指向调用该方法的 对象（实例），它的最大作用是：让类中的一个方法，调用类中的另一个方法或属性。

　　static修饰的方法中不能使用 this，因为它是静态成员（属于类共有，类调用时没有创建实例），无法指向合适的对象（静态成员不能直接访问非静态成员）。

public class Dog{
    public void jump(){
        System.out.println("执行jump方法");
    }
    public void run(){
        this.jump(); //jump(); //java允许一个对象直接调用另一个对象，一般情况下this可以省略
        System.out.println("执行run方法");
    }
}

 

　  this与super的区别是什么？

　　this 总是指向调用该方法的 对象（实例），它的最大作用是：让类中的一个方法，调用类中的另一个方法或属性。

　　this的用法在java中大体可以分为3种：

　　1.普通的直接引用，this相当于是指向当前对象本身。

　　2.形参与成员名字重名，用this来区分，即如果方法(构造器)里有一个局部变量和属性同名，但要在方法里访问这个被覆盖的属性，则必须用this前缀。

　　3.引用本类的构造函数。

 

　　super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

　　super也有三种用法：

　　1.普通的直接引用：与this类似，super相当于是指向当前对象的父类的引用，这样就可以用super.xxx来引用父类的成员。

　　2.子类中的成员变量或方法与父类中的成员变量或方法同名时，用super进行区分；

　　3.引用父类构造函数：

　　　　super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。

　　　　this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。

 

　　super() 和 this() 的区别是：

　　　　super() 在子类中调用父类的构造方法，this() 在本类内调用本类的其它构造方法。

　　　　super() 和 this() 均需放在构造方法内第一行。

　　　　尽管可以用 this 调用一个构造器，但却不能调用两个。

　　　　this 和 super 不能同时出现在一个构造函数里面。因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，

　　　　所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

　　　　this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量、static方法、static语句块。

　　　　从本质上讲，this 是一个指向本对象的指针, 然而 super 是一个Java关键字。

 

5.2、 方法详解

　　Java语言里，方法不能独立存在，方法必须属于类或对象。一旦将一个方法定义在某个类的类体内，如果这个方法使用了static 修饰，则这个方法属于这个类，否则这个方法属于这个类的 实例。

　　Java里方法的参数传递方式只有一种：值传递。所谓值传递，就是将实际参数值的副本（复制品）传入方法内，而参数本身不会受到任何影响。

　　

　　形参长度可变的方法：从JDK 1.5之后，Java允许为方法指定数量不确定的形参。如果在定义方法时，在最后一个形参的类型后增加三点（...），则表明该形参可以接受多个参数值，多个参数值被当成数组传入。

　　注意事项：

　　　　1、一个方法中最多 只能包含一个 个数可变的形参；

　　　　2、个数可变的形参 只能处于形参列表的最后；

　　　　3、个数可变的形参 本质就是一个数组类型，因此调用时，该形参既可以传入多个参数，也可以传入一个数组。

public static void test(int a, String ... books); //以可变个数形参定义方法，只能有一个，只能处于形参列表最后，传值时可以传数组
public static void test(int a, String[] books); //效果同上

test(5, "语文", "数学");  //可变个数形参方法赋值，调用方法时根据简洁
test(5, new String[]{"语文", "数学"}); //赋值，可用于上面两个方法

 

　　方法递归：一个方法体内调用它自身，被称为方法递归。只要一个方法的方法体实现中再次调用了方法本身，就是递归方法。递归一定要向已知方向递归。

　　方法重载：如果同一个类中包含了两个或两个以上方法的 方法名相同，但形参列表不同，则被称为方法重载。

    /**
     * 递归方法：一个方法体内调用自身，向已知方向递归
     * 示例1：已知一个数列：f(0)=1, f(1)=4, f(n+2)=2*f(n+1) + f(n),其中n是大于0的整数，求f(10)
     * 分析：f(0)、f(1) 已知，求f(10)，向小的方向递归，通用公式变为:f(n)=2*f(n-1) + f(n-2) 
     * 即将 n = n-2,使得向f(1)、f(0)方向递归(向已知方向递归)
     */
    public static int fn(int n) {
        if(n==0) {
            return 1;
        } else if(n==1) {
            return 4;
        } else {
            return 2 * fn(n-1) + fn(n-2); //方法中调用它自身，就是方法递归
        }
    }
    
    /**
     * 递归方法：一个方法体内调用自身，向已知方向递归
     * 示例2：已知一个数列：f(20)=1, f(21)=4, f(n+2)=2*f(n+1) + f(n),其中n是大于0的整数，求f(10)
     * 分析：f(20)、f(21) 已知，求f(10)，向大的方向递归，通用公式变为:f(n)=f(n+2) - 2*f(n+1)
     * 向f(20)、f(21)方向递归(向已知方向递归)
     */
    public static int fn2(int n) {
        if(n==20) {
            return 1;
        } else if(n==21) {
            return 4;
        } else {
            return fn2(n+2) - 2 * fn2(n+1); //方法中调用它自身，就是方法递归
        }
    }
    
    //方法重载
    public void test(String str) {
        System.out.println("只有一个字符串的test方法");
    }
    
    public void test(String ... books) {
        System.out.println("形参长度可变的test方法");
    }
    
    
    public static void main(String[] args) {
        //递归方法测试
        System.out.println(fn(10)); //输出fn(10)的结果为： 10497
        System.out.println(fn2(10)); //输出fn2(10)的结果为： -3771
        
        TaskEveryTenMin t = new TaskEveryTenMin();
        //执行第一个test方法，打印出：只有一个字符串的test方法
        t.test("aa"); 
        
        //执行第二个test方法，下面三个都打印出：形参长度可变的test方法
        t.test();
        t.test("aa", "bb");
        t.test(new String[] {"aa"}); //想调用第二个方法，又想只传一个字符串参数则调用这个方法,可传一个字符串数组
        
    }
    

 

5.3、 成员变量和局部变量

　　成员变量：指的是在 类里定义的变量；

　　局部变量：指的是在 方法里定义的变量。

　　变量名称建议：第一个单词首字母小写，后面每个单词首字母大写。Java程序中的变量划分如下图所示：

 　　1、成员变量 无须显式初始化。系统 会在 加载类 或 创建该类的实例 时，自动为成员变量分配内存空间，自动为成员变量指定初始值。

 　　2、局部变量 除形参之外，都必须显式初始化。也就是说，必须先给方法局部变量和代码块局部变量指定初始值，否则不可以访问它们。

 

 　　3、局部变量定义后，必须经过显式初始化后才能使用，系统不会为局部变量执行初始化。这意味着定义局部变量后，系统并未为这个变量分配内存空间，直到等到程序为这个变量赋初始值时，

　　系统才会为局部变量分配内存，并将初始值保存到这块内存中。与成员变量不同，局部变量不属于任何类或实例，因此它总是保存在其所在方法的栈内存中。

　　如果局部变量是基本类型的变量，则直接把这个变量的值保存在该变量对应的内存中；如果局部变量是一个引用类型的变量，则这个变量里存放的是地址，

　　通过该地址引用到该变量实际引用的对象或数组。栈内存中的变量无须系统垃圾回收，往往随方法或代码块的运行结束而结束。

 

5.4、 隐藏和封装

　　封装实际上有两个方面的含义：把该隐藏的隐藏起来，把该暴露的暴露出来。这两个方面都需要通过使用Java提供的访问控制符来实现。

　　Java提供了4个访问控制符：private、default、protected 、public，提供了4个访问控制级别。Java的访问控制级别由小到大如下图所示：

 

 　　关于访问控制符的使用，存在如下几条基本原则：

 　　1、类里的绝大部分成员变量都应该使用private修饰，只有一些static修饰的、类似全局变量的成员变量，才可能考虑使用public修饰。

　　　　除此之外，有些方法只用于辅助实现该类的其他方法，这些方法被称为工具方法，工具方法也应该使用private修饰。

 

 　　2、 如果某个类主要用做其他类的父类，该类里的大部分方法可能仅希望被其子类重写，而不想被外界直接调用，则应该使用protected修饰这些方法。

 　　3、希望暴露出来给其他类自由调用的方法应该使用public修饰。因此，类的构造器通常使用public修饰，从而允许在其他地方创建该类的实例。

 

　　4、package 语句必须作为源文件的第一条非注释性语句，一个源文件只能指定一个包，即只能包含一条package语句，

　　　　该源文件中可以定义多个类，则这些类将全部位于该包下。如果没有显式指定package语句，则处于默认包下。

　　5、import 可以向某个Java文件中导入指定包层次下某个类或全部类，import语句应该出现在package语句（如果有的话）之后、类定义之前。

　　6、JDK 1.5以后更是增加了一种静态导入的语法，它用于导入指定类的某个静态成员变量、方法或全部的静态成员变量、方法。

　　　　静态导入使用 import static 语句，静态导入也有两种语法，分别用于导入指定类的单个静态成员变量、方法和全部静态成员变量、方法。

 

　　Java的核心类都放在java包以及其子包下，Java扩展的许多类都放在javax包以及其子包下。

　　下面几个包是Java语言中的常用包：

 　　java.lang：这个包下包含了Java语言的核心类，如String、Math、System和Thread类等，使用这个包下的类无须使用import语句导入，系统会自动导入这个包下的所有类。

　　 java.util：这个包下包含了Java的大量工具类/接口和集合框架类/接口，例如Arrays和List、Set等。

　　 java.net：这个包下包含了一些Java网络编程相关的类/接口。

　　 java.io：这个包下包含了一些Java输入/输出编程相关的类/接口。

　　 java.text：这个包下包含了一些Java格式化相关的类。

　　 java.sql：这个包下包含了Java进行JDBC数据库编程的相关类/接口。

　　 java.awt：这个包下包含了抽象窗口工具集的相关类/接口，这些类主要用于构建图形用户界面（GUI）程序。

　　java.swing：这个包下包含了Swing图形用户界面编程的相关类/接口，这些类可用于构建平台无关的GUI程序。

 

5.5、 深入构造器

　　构造器最大的用处就是在创建对象时执行初始化。同一个类里具有多个构造器，多个构造器的形参列表不同，即被称为 构造器重载。

　　使用this调用另一个重载的构造器只能在构造器中使用，而且必须作为构造器执行体的第一条语句。使用this调用重载的构造器时，系统会根据this后括号里的实参来调用形参列表与之对应的构造器。

 

5.6、 类的继承

　　Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类被称为父类，有的也称其为基类、超类。父类和子类的关系，是一种一般和特殊的关系。

　　注意：子类只能从父类获得 成员变量、方法和内部类（包括内部接口、枚举），不能获得 构造器和初始化块。

　　如果定义一个Java类未显式指定这个类的直接父类，则这个类默认扩展java.lang.Object类。因此，java.lang.Object类 是所有类的父类，要么是其直接父类，要么是其间接父类。

 

　　方法重写：子类包含与父类同名方法的现象被称为方法重写（Override），也被称为方法覆盖。可以说子类重写了父类的方法，也可以说子类覆盖了父类的方法。

　　方法的重写要遵循“两同两小一大”规则：

　　　　“两同”即方法名相同、形参列表相同；

　　　　“两小”指的是子类方法 返回值类型 应比父类方法返回值类型更小或相等，子类方法声明 抛出的异常类 应比父类方法声明抛出的异常类更小或相等；

　　　　“一大”指的是子类方法的 访问权限 应比父类方法的访问权限更大或相等。尤其需要指出的是，覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法，不能一个是类方法，一个是实例方法。

 

　　当子类覆盖了父类方法后，子类的对象将无法访问父类中被覆盖的方法，但可以在子类方法中调用父类中被覆盖的方法。

　　如果需要在子类方法中调用父类中被覆盖的方法，则可以使用super（被覆盖的是实例方法）或者父类类名（被覆盖的是类方法）作为调用者来调用父类中被覆盖的方法。

 

　　如果父类方法具有private访问权限，则该方法对其子类是隐藏的，因此其子类无法访问该方法，也就是无法重写该方法。

　　如果子类中定义了一个与父类private方法具有相同的方法名、相同的形参列表、相同的返回值类型的方法，依然不是重写，只是在子类中重新定义了一个新方法。

 

　　方法重载：主要发生在 同一个类的 多个 同名方法之间，而重写发生在 子类和父类 的 同名方法 之间。

　　super是Java提供的一个关键字，super用于限定该对象调用它从父类继承得到的实例变量或方法。

 

5.7、 多态

　　Java引用变量有两个类型：一个是 编译时类型，一个是 运行时类型。

　　编译时类型 由声明该变量时使用的类型决定，运行时类型 由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态（Polymorphism）。

　　多态：相同类型的变量 调用同一个方法时呈现出 多种不同的行为特征，这就是多态。与方法不同的是，对象的实例变量则不具备多态性。

 

　　instanceof 运算符的前一个操作数通常是一个引用类型变量，后一个通常是一个类（或接口，可以把接口理解成一种特殊的类），它用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。是则返回true，否则false。

　　在使用instanceof运算符时需要注意：instanceof 运算符前面操作数的编译时类型要么与后面的类相同，要么与后面的类具有父子继承关系，否则会引起编译错误。

 

5.8 、继承与组合

　　继承是实现类复用的重要手段，但继承带来了一个最大的坏处：破坏封装。相比之下，组合也是实现类复用的重要方式，而采用组合方式来实现类复用则能提供更好的封装性。

　　子类扩展父类时，子类可以从父类继承得到成员变量和方法，如果访问权限允许，子类可以直接访问父类的成员变量和方法，相当于子类可以直接复用父类的成员变量和方法。

 

　　为了保证父类有良好的封装性，不会被子类随意改变，设计父类通常应该遵循如下规则：

 　　1、尽量隐藏父类的内部数据。尽量把父类的所有成员变量都设置成private访问类型，不要让子类直接访问父类的成员变量。

　　 2、不要让子类可以随意访问、修改父类的方法。父类中那些仅为辅助其他的工具方法，应该使用private访问控制符修饰，让子类无法访问该方法；

　　如果父类中的方法需要被外部类调用，则必须以 public 修饰，但又不希望子类重写该方法，可以使用 final 修饰符来修饰该方法；

　　如果希望父类的某个方法 被子类重写，但 不希望被其他类自由访问，则可以使用 protected 来修饰该方法。

 

　　3、尽量不要在父类构造器中调用将要被子类重写的方法。

　　4、如果想把某些类设置成最终类，即不能被当成父类，则可以使用 final 修饰这个类，例如JDK提供的 java.lang.String 类 和 java.lang.System 类。

　　5、除此之外，使用 private 修饰这个类的所有构造器，从而保证子类无法调用该类的构造器，也就无法继承该类。对于把所有的构造器都使用private修饰的父类而言，可另外提供一个静态方法，用于创建该类的实例。

　　6、如果需要复用一个类，除把这个类当成基类来继承之外，还可以把该类当成另一个类的组合成分，从而允许新类直接复用该类的public方法。

 

5.9、 初始化块

　　一个类里可以有多个初始化块，相同类型的初始化块之间有顺序：前面定义的初始化块先执行，后面定义的初始化块后执行。

 　　在 Java 语言中，当实例化对象时，对象所在类的所有 成员变量 首先要进行初始化，只有当所有类成员完成初始化后，才会调用对象所在类的构造函数创建象。

 

 　　初始化一般遵循3个原则：

　　1、静态对象（变量）优先于非静态对象（变量）初始化，静态对象（变量）只初始化一次，而非静态对象（变量）可能会初始化多次；

　　2、父类优先于子类进行初始化；

　　3、按照 成员变量的定义顺序 进行初始化。 即使变量定义散布于方法定义之中，它们依然在任何方法（包括构造函数）被调用之前先初始化；

　　加载顺序：

　　父类（静态变量、静态语句块）
　　子类（静态变量、静态语句块）

　　父类（实例变量、普通语句块）
　　父类（构造函数）

　　子类（实例变量、普通语句块）
　　子类（构造函数）