Java学习笔记——面向对象核心技术（一）

类的封装

封装是面向对象编程的核心思想。封装的载体是类，且对象的属性和行为被封装在这个类中。

package way_of_Class_practice
/*对厨师进行类的封装*/
public class Restaurant {
    /* 定义一个厨师类 */
    class Cook{
        private String name; //厨师的名字
        public Cook(){
            this.name="Tom
Smith"; //厨师的名字叫汤姆.史密斯
        }
        private void cutOnion() { //厨师切洋葱
            System.out.println(name+"切洋葱");
        }
        private void washVegetavles() {//厨师洗蔬菜
            System.out.println(name+"洗蔬菜");
        }
        void cooking(String dish) {
            washVegetavles();
            cutOnion();
            System.out.println(name+"开始烹饪"+dish);
        }
    }        
        /*餐厅开始封装厨师*/
        private Cook cook = new Cook();
    public void takeOrder(String dish) {
        cook.cooking(dish);
        System.out.println("您的菜好了，请慢用！");
    }
    public String saySorry() {
        return "抱歉！餐厅不提供此项服务";
    } 
    public static void main(String[] args) {
        Restaurant waiter = new Restaurant();
        System.out.println("**请让厨师为我做一份鱼香肉丝**");
        waiter.takeOrder("鱼香肉丝");
        System.out.println("**你们厨师叫什么名字***");
	System.out.println(waiter.saySorry());
        System.out.println("**请让厨师为我切一点葱花**");
        System.out.println(waiter.saySorry());
    }
}

类的继承

继承的基本思想是基于某个父类的扩展，并制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加原来父类所不具备的属性和方法。或者直接重写父类中的某些方法。

extends关键字
在Java中，让一个类继承另一个类需要使用extends关键字。
语法：
Child extends Parents

说明：子类Child在继承父类Parents类的同时，也继承了父类Parents类中的属性和方法

**> 注意：Java仅支持单继承，及一个类只可以有一个父类，类似如下面的继承是错误的：

Child extends Parents1，Parents2{//错误的继承语法

}

例：
quad类：

package way_of_Class_practice;
public class quad {
    public void feature1() {
        System.out.println("四边形的有四条边")
    }
    public void feature2() {
        System.out.println("四边形的四个内角之和为360度");
    }
}

Rectangle类：

package way_of_Class_practice;
public class rectangle extends quad {
    public void feature3() {
        System.out.println("长方形的四个角都是直角");
}
    public void feature4() {
        System.out.println("长方形的对边相等");
    }
    public void feature5() {
        System.out.println("长方形的对角线互相平分且相等");
    }
    public static void main(String[] args) {
        quad draw1 = new quad();
        draw1.feature1();
        draw1.feature2();
        System.out.println("****************************");
        rectangle draw2 = new rectangle();
        draw2.feature1();
        draw2.feature2();
        draw2.feature3();
        draw2.feature4();
    }
}

方法的重写
父类的成员都会被子类继承，当父类中的某个方法并不适用于子类时，就需要在子类中重写父类的这个方法。

1、 重写的实现
继承不只是扩展父类的功能，还可以重写父类的成员方法。重写（覆盖）是指在子类中将父类的成员方法名称保留，重新编写父类成员方法的实现内容，更改成员方法的权限，或是修改成员方法的返回值类型。

在继承中还有一种特殊的重写方式，子类和父类的成员方法返回值、方法名称、参数类型及个数完全相同，唯一不同的是方法实现内容，也就是所谓的“重构”。

注意：当重写父类方法时，修改方法的修饰权限只能从小的范围到大的范围改变。如父类中doSomething()方法的修饰权限为protected，继承后子类中的方法doSomething()的修饰权限只能修改为public，不能修改为private。

2、 Super关键字
若在子类重写了父类的方法后还想调用父类的方法，此时可以调用super关键字，super关键字代表了父类对象。

语法：

super.feature1();  
super.feature;

所有类的父类——Object类

Object类是比较特殊的类，它是所有类的父类，是Java层中最高层类，在Object类中主要包括clone()、finalize()、equals()、toString()等方法，其中常用的两个方法为equals()和toString()方法。

注意：Object类中getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。

1、 getClass()方法

getClass()方法会返回某个对象执行时的Class实例，然后通过Class实例调用getName()方法获取类的名称。

语法：getClass().getName()；

2、 toString()方法

toString()方法会返回某个对象的字符串表示形式，当打印某个类对象时，将自动调用重写的toString()方法

3、 equals()方法

Object类中的equals()方法比较的是两个对象引用的地址是否相等

类的多态

类的多态主要重两个方面体现，一个是方法的重载；一个是类的上下转型。

方法的重载：

构造方法的名称由类名决定的，若以不同的方式创建某个类的对象，就需要用多个形参不同的构造方法来完成。为了让这些方法名相同但形参不同的构造方法同时存在，就需要用到“方法的重载”

方法的重载是指在同一个类中允许同时存在多个同名方法，只是这些方法的参数个数或类型不同。

例：

package way_of_Class_practice;
public class OverLoadTest {
//  定义一个方法
    public static int add(int a) {
        return a;
    } 
//定义一个与第一个参数不同的方法
    public static int add(int a, int b) {
        return a + b;
    } 
//  定义一个方法名相同，参数类型不同的方法
    public static double add(double a, double b) {
        return a + b;
    }
//  定义一个不定长参数
    public static int add(int... a) {
        int sum = 0;// 局部变量要初始化
        for (int i = 0; i < a.length; i++)
            sum += a[i];
        return sum;
    } 
//  主函数
    public static void main(String[] args) {
        System.out.println("调用add(int)方法：" + add(1));
        System.out.println("调用add(int,int)方法：" + add(1, 3));
        System.out.println("调用add(double,double)方法：" + add(5.6, 2.4));
        System.out.println("调用add(int... a)不定长参数方法：" + add(1, 2, 3, 4, 5, 6));
    }
}

向上转型

将子类看做是父类的对象被称为“向上转型”。由于向上转型是从一个较具体的类到较抽象的类的转换，所以向上转型是安全的。例如：可以说平行四边形是特殊的四边形，但不能说四边形是平行四边形。

注意：在执行向上转型操作时，父类的对象无法调用子类独有的属性或者方法。

Quadrangle类：

package way_of_Class_practice;
public class Quadrangle {
    public static void draw(Quadrangle q)
    {        
    }
}

Parallelogram 类

package way_of_Class_practice;
public class Parallelogram extends Quadrangle{
    public static void main(String[] args) {
        Parallelogram p = new
Parallelogram();
        p.draw(p);
    }
}

向下转型

在做向下转型操作时，将抽象的对象（四边形）转换为具体的对象（平行四边形）时会报错误的。此时需要将父类对象强制转换为某个子类对象的方式被称为显示类型转换。
Parallelogram 类

package way_of_Class_practice;
public class Parallelogram extends Quadrangle {
    public static void main(String[] args) {
        draw(new Parallelogram());
//      将平行四边形对象看做是四边形对象，称为向上转型操作
        Quadrangle q = new
Parallelogram();
//      将父类对象赋予子类对象
        Parallelogram p = q;
        // p.draw(p);
    }
}

Parallelogram 类

package way_of_Class_practice;
public class Parallelogram extends Quadrangle {
    public static void main(String[] args) {
        draw(new Parallelogram());
//      将平行四边形对象看做是四边形对象，称为向上转型操作
        Quadrangle q = new Parallelogram();
//      将父类对象赋予子类对象，并强制转化为子类对象
        Parallelogram p = (Parallelogram) q;
        // p.draw(p);
    }
}

注意：当使用显示类型转换向下转型时，必须向编译器指明将父类对象转换为哪一种类型的子类对象。

Instanceof关键字

程序执行向下转型操作时，若父类对象不是子类实例，就会发生ClassCastException异常，所以在执行向下转型之前需要使用instanceof关键字判断父类对象是否为子类的实例。Instanceof关键字还可以判断某个类是否实现某个接口。

语法：

myobject instanceof ExampleClass
myobject：某类对象的引用   ExamepleClass:某个类 ；

使用instanceof关键字的表达式返回的是布尔值，若返回true，说明myobject对象为ExampleClass实例；若返回false，说明myobject对象不是ExampleClass的实例。

例：
Parallelogram1 类

package way_of_Class_practice; 
public class Parallelogram1 extends Quadrangle1{
    public static void main()
    {
        Quadrangle1 q = new Quadrangle1();
//      判断父类四边形类对象是否为平行四边形类的实例
        if(q instanceof Parallelogram1) {
            Parallelogram1 p = (Parallelogram1)q;
        }
//      判断父类四边形类对象是否为正方形类的实例
        if(q instanceof Square) {
            Square s = (Square)q;
        }
    }
}

总结：

当父类调用子类特有的属性时会报错。

当p不是类的实例时会报错

当