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(){

...;

}

 

你可能感兴趣的:(JAVA学习)