JAVA 学习随笔记录 （五）面向对象核心技术

类的封装

封装的载体是类，且对象的属性和行为被封装在这个类中。

例：通过封装性封装厨师的具体信息，厨师只负责烹饪，所有的服务均有服务员来完成。

package unit1;

public class Restaurant0 {
    private Cook cook=new Cook();
    public String waitername="David";
    public void TakeOrder(String dish) {
        cook.cooking(dish);
        System.out.println(waitername+":菜好了，请慢用！");
    }
    public String SaySorry() {
        return "抱歉，本店不提供此服务";
    }
    class Cook{
        private String name;
        public Cook() {
            this.name="Tommy";
        }
        private void CutOnion() {
            System.out.println(name+"开始切洋葱");
        }
        private void WashVegetables() {
            System.out.println(name+"开始洗蔬菜");
        }
        void cooking(String dish) {
            CutOnion();
            WashVegetables();
            System.out.println(name+"开始烹饪"+dish);
        }
    }
    public static void main(String args[]) {
        Restaurant0 waiter=new Restaurant0();
        System.out.println("请为我做一个鱼香肉丝");
        waiter.TakeOrder("鱼香肉丝");
        System.out.println("请告诉我你们厨师的名字");
        System.out.println(waiter.SaySorry()); 
        
    }
}

 类的继承

在JAVA中让子类继承父类需要使用extends关键字，语法如下：

Child extends Parents

子类在继承了父类的同时，也继承了父类的属性与方法，且一个类只能继承一个父类，也可以在子类中扩展自己的方法甚至直接重写父类中的某些方法。

例：使用继承方法继承父类属性，并添加自己的属性

package unit1;

public class Computer {
        String screen="液晶显示屏";
        void startup() {
        System.out.println("电脑正在开机，请稍等");
    }
public static class Pad extends Computer{
            String battery="5000毫安电池";
            public static void main(String args[]) {
                Computer pc=new Computer();
                System.out.println("computer的屏幕是："+pc.screen);
                pc.startup();
                Pad ipad=new Pad();
                System.out.println("ipad的屏幕是："+ipad.screen);
                System.out.println("ipad的电池容量是："+ipad.battery);
                ipad.startup();
            }
    }
}

注意：将主函数放在继承的子类中时，继承子类需加上static属性，使其供全局所有。

方法的重写

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

重构：特殊的重写方式，子类与父类的成员方法返回值、方法名称、参数类型及个数完全相同，唯一不同的是方法的实现内容。

注意：重写父类的方法时，只能从小的范围到大的范围改变，例如父类方法中是private，子类继承重写只能将其改为public或者不变。

例：方法的重写

package unit1;

public class Computer2 {
    void ShowPicture() {
        System.out.println("鼠标点击！");
    }
    public static class Pad2 extends Computer2 {
        void ShowPicture() {
            System.out.println("手指点击触摸屏！");
        }
        public static void main(String args[]) {
            Computer2 pc=new Computer2();
            System.out.println("pc打开图片：");
            pc.ShowPicture();
            Pad2 ipad=new Pad2();
            System.out.println("iPad打开图片：");
            ipad.ShowPicture();
        }
    }
}

super关键字

如果子类重写了父类的方法，想在子类方法中实现父类原有的方法，使用super关键字可以完成操作，语法格式：

super.property;  //调用父类的属性

super.method(); //调用父类的方法

所有类的父类Object类

在JAVA中所有的类都直接或间接继承了java.lang.Object 类

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

toString()方法：本方法会返回某个对象的字符串表达形式

类的多态性

多态性的定义是一种定义，多种实现，例如，运算符+作用于两个整形的中间是求和，作用于两个字符串之间是连接作用。类的多态性体现在两方面，第一：方法的重载，第二：类的上下转型.

方法的重载

构造方法的名称由类名决定，如果以不同的方式创建某个类的对象，就需要使用多个形参不同的构造方法来完成，这些方法名称相同但形参不同。

例：使用重载对不同形参进行操作

package unit1;

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,double b) {
        return (int)(a+b);
    }
    public static int add(double a,int b) {
        return (int)(a+b);
    }
    public static void main(String args[]) {
        System.out.println("调用add(int):"+add(1));
        System.out.println("add(int,int):"+add(1,2));
        System.out.println("add(double,double):"+add(2.1,3.3));
        System.out.println("add(int,double):"+add(1,3.3));
        System.out.println("add(double,int):"+add(2.1,3));
    }
}

向上转型

在JAVA中，对象类型的转换包括向上转型和向下转型，例如平行四边形是特殊的四边形，也就是说平行四边形是四边形的一种，那么就可以将平行四边形对象看作是一个四边形对象，即在子类中可以安全调用父类的方法。

例如：使用向上转型，使子类继承父类，然后在主函数中调用父类方法

package unit1;

public class Quadrangle {
    public static void draw(Quadrangle q) {
        System.out.println("绘画一个图形");
    }
    
public static class Parallelogram extends Quadrangle{
    public static void main(String args[]) {
        Parallelogram p=new Parallelogram();
        draw(p);
    }
}
}

抽象类与抽象方法

把类似无法使用具体语言定义的图形类称为抽象类，在JAVA中，抽象类不能产生实例对象，语法格式如下：

abstract class 类名{
类体；

}

使用abstract修饰的方法称之为抽象方法，定义格式如下：

[权限修饰符] abstract 方法返回值类型 方法名（参数列表）；

抽象方法必须承载到抽象类中去，而抽象类存在的唯一作用就是被继承，在子类中重写对应的抽象方法。

例如，在抽象类中进行如下操作：

package unit1;

public abstract class Market {
    public String name;
    public String goods;
    public abstract void shop();
}

package unit1;

public class TaobaoMarket extends Market {

    @Override
    public void shop() {
        // TODO Auto-generated method stub
        System.out.println(name+"网购"+goods);
    }
}

package unit1;

public class WallMarket extends Market {

    @Override
    public void shop() {
        // TODO Auto-generated method stub
        System.out.println(name+"实体店购买"+goods);
    }

}

 

 

package unit1;

public class GoShopping {
    public static void main(String args[]) {
        Market market=new WallMarket();
        market.name="沃尔玛";
        market.goods="七匹狼";
        market.shop();
        market=new TaobaoMarket();
        market.name="淘宝";
        market.goods="短袖";
        market.shop();
    }
}

接口的声明及实现

接口是抽象的延申，可以将它看作是抽象类，接口中的所有方法都没有方法体，都是抽象方法等待继承，接口只可以继承接口，当几个不同类的类想完成共同的操作实现多态性时，需要定义接口，在各个类中实现接口，在主函数中调用接口，传递相应的参数，实现多态性，语法格式：

[修饰符] interface 接口名 [extends 父接口名列表]{
 [public] [static][final]常量；

[public] [abstract] 方法;

}

多重继承

使用接口可以实现多重继承

语法格式：

ass 类名 implements 接口1，接口2，接口3

final关键字

被final关键字修饰的类、方法、变量不能被改变，被其修饰的类不能被继承，并且不允许任何人对此类进行改动，被其修饰的方法不能被重写。

成员内部类与匿名内部类

在一个类中除了定义成员变量与方法外还可以定义一个内部类，例如在汽车类中可以定义一个发动机类。

匿名内部类特点是只需要使用一次，匿名内部类不能被重复使用，创建完一次实例后立即销毁掉。

new A(){

...;

}