面向对象进阶8--包、修饰符、final、常量、枚举、抽象类、枚举

面向对象进阶8–包、修饰符、final、常量、枚举、抽象类、枚举

包

什么是包

权限修饰符

什么是权限修饰符&权限修饰符的作用范围

学完权限修饰符需要具备

代码演示

同一个类下4种情况

package modifiter;

public class FU {
    // private 只能本类访问
    private void showprivate(){
        System.out.println("private");
    }
    // void 本类，同一个包下的类均可以使用
    void showvoid(){
        System.out.println("void");
    }

    // protected: 本类，同一个包下的类中，其他包下的子类
    protected void showprotected(){
        System.out.println("protected");
    }

    // public：均可以
    public void showpublic(){
        System.out.println("public");
    }


    public static void main(String[] args) {
        FU f = new FU();
        f.showprivate();
        f.showvoid();
        f.showprotected();
        f.showpublic();
    }
}

运行结果

不同类下的运行结果

package com.peihj.modifiter;

public class demo {
    public static void main(String[] args) {
        // 创建父类对象看一下哪些地方可以调用
        FU f = new FU();
        f.showpublic();
        f.showprotected();
        f.showvoid();

    }
}

运行结果

如果强制调用私有private属性会报错

报错提示

不同包下调用protected调用不了，这是因为这时候不同包下的程序还不是子类，没有利用继承的用法

父类对象

package com.peihj.modifiter;

public class FU {
    // private 只能本类访问
    private void showprivate(){
        System.out.println("private");
    }
    // void 本类，同一个包下的类均可以使用
    void showvoid(){
        System.out.println("void");
    }

    // protected: 本类，同一个包下的类中，其他包下的子类
    protected void showprotected(){
        System.out.println("protected");
    }

    // public：均可以
    public void showpublic(){
        System.out.println("public");
    }


    public static void main(String[] args) {
        FU f = new FU();
        f.showprivate();
        f.showvoid();
        f.showprotected();
        f.showpublic();
    }
}

子类对象

package com.peihj.ittry;

import com.peihj.modifiter.FU;

public class zi extends FU{
    public static void main(String[] args) {
        // 创建子类对象看一下哪些地方可以调用
        zi z = new zi();
        z.showpublic();
        z.showprotected();
//        f.showvoid();
//        f.showprivate();
    }
}

运行结果

不同包下的不同的程序

package com.peihj.ittry;

import com.peihj.modifiter.FU;

public class demo {
    public static void main(String[] args) {
        FU f = new FU();
//        f.showprivate();
//        f.showvoid();
//        f.showprotected();
        f.showpublic();
    }
}

final

final修饰成员变量的作用以及注意事项

final修饰类之后，类无法被继承

package com.peihj.Final;
/*
* 目标：明白final一些基本注意事项
* */
public class Test {
    public static void main(String[] args) {

    }
// final修饰类，类不可以被继承了
final class Animal{

}    
class Cat extends Animal{
}
}

报错提示

final修饰方法，方法不可以被重写

正常情况

package com.peihj.Final;
/*
* 目标：明白final一些基本注意事项
* */
public class Test {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.run();


    }
}
// final修饰类，类不可以被继承了
class Animal{
        public void run(){
            System.out.println("动物可以跑--");
        }

}

class Cat extends Animal{
    @Override
    public void run() {
//        super.run();
        // 就近原则
        System.out.println("子类动物跑--");
    }
}

final修饰后情况

final修饰成员变量，变量有且只可以被赋值一次

final修饰类：表明该类是最终类，不能被继承。

最终类，牵一发而动全身，类似全局变量，不可以不赋值，又不可以只赋值多次，只可以赋值1次。

final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。

final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。

package com.peihj.Final;
/*
* 目标：明白final一些基本注意事项
* */
public class Test {
    public static void main(String[] args) {
        // final修饰成员变量的注意事项
        // final修饰基本类型变量，其数据值不能改变
        final double rate = 0.01;
//        rate = 0.02; 第二次赋值报错
        // final修饰引用数据类型变量，变量中存储的地址不能被改变，但是地址指向的内容可以改变

        final int[] arr = {10,20,30};
        System.out.println(arr);
//        arr = null; // 属于第二次赋值保存,报错

        arr[1] = 200;
        System.out.println(arr);
        System.out.println(arr[1]);
    }
}

测试结果

常量

常量的概述与基本作用

枚举

枚举的概述

反编译后观察枚举的特征

枚举的特征演示

抽象类

抽象类概述

抽象类代码演示

抽象父类

package com.peihj.Abstract;

public abstract class Animals {
    public abstract void run();
}

抽象子类，方法重写

package com.peihj.Abstract;

public class Tiger extends Animals{
    @Override
    public void run() {
        System.out.println("抽象方法！");
    }
}

测试类

package com.peihj.Abstract;

public class Tiger extends Animals{
    @Override
    public void run() {
        System.out.println("抽象方法！");
    }
}

结果演示

抽象类使用注意事项

小结

抽象类案例

父类方法

package com.peihj.CardDemo;

public abstract class card {
    private String name; // 主人名称
    private double money; // 金额

    /*
    * 子类一定要支付但是每个子类的方法都不一样所以定义为抽象类
    * */
    public abstract void pay(double money);

    public card() {
    }

    public card(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

子类方法

package com.peihj.CardDemo;

public class goldcard extends card{
    @Override
    public void pay(double money) {
        double rs = money*0.8;
        double lastMoney = getMoney() - rs;  // 剩余金额
        setMoney(lastMoney);  // 更新账户余额
        System.out.println(getName()+"本次消费："+rs+",账户剩余的金额为："+lastMoney);
    }
}

测试方法

package com.peihj.CardDemo;

public class Test {
    public static void main(String[] args) {
        goldcard g = new goldcard();
        g.setName("乔巴");
        g.setMoney(10000.00);
        g.pay(300);
    }
}

运行结果

特征类的注意事项

有得有失，得到了抽象方法就失去创建对象的能力

final和abstract是什么关系？

模板方法模式

案例：银行利息结算系统

父类方法

package com.peihj.BANK;

public abstract class Account {
    private String cardid;
    private double money;
    private String loginname = "peihuanjie";
    private String loginpassword = "123456";

    public void handle(String loginName,String password){
        // 判断是否结算成功
        if (loginname.equals(loginName)&(loginpassword.equals(password))){
                System.out.println("登录成功");
                // 正式结算利息
                // 当前模板的子类都需要结算利息但是结算利息的方法不一样具体如何算模板不清楚，定义成抽象类
                double result = calc();
                System.out.println("本账户的利息是："+result);
        }else {
                System.out.println("用户名或者密码错误");
        }
    }


    public abstract double calc();

    public Account() {
    }

    public Account(String cardid, double money) {
        this.cardid = cardid;
        this.money = money;
    }

    public String getCardid() {
        return cardid;
    }

    public void setCardid(String cardid) {
        this.cardid = cardid;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

子类1

package com.peihj.BANK;


/*
* 定期账户
* */
public class FixedAccount extends Account {

    /*登录结算
     * */

    @Override
    public double calc() {
        double result = getMoney() * (0.03);
        return result;
    }

    public FixedAccount(String cardid, double money) {
        super(cardid, money);
    }

}

子类2

package com.peihj.BANK;

public class CurrentAccount extends Account {
    /*
     * 登录结算利息
     * */
    // 共同方法定义抽象类
    public CurrentAccount(String cardid,double money){
        super(cardid,money);
    }
    @Override
    public double calc() {
        double result = getMoney() * 0.0175;
        return result;
    }
}

测试

package com.peihj.BANK;

public class Test {
    public static void main(String[] args) {
        CurrentAccount acc = new CurrentAccount("ICBC",10000);
        acc.handle("peihuanjie","123456");

        FixedAccount f = new FixedAccount("icbc",50000);
        f.handle("peihuanjie","123456");
    }
}

运行结果

模板方法建议用final修饰

小结

接口

什么是接口

接口的定义以及特点

代码演示

package com.peihj.interfacedemo;

public interface SportMan {
    void run();
    void competition();
}

package com.peihj.interfacedemo;

public interface Law {
    void rule();
}

package com.peihj.interfacedemo;

public interface people {
    void eat();
}

子类继承方法必须对方法进行重写，快捷键alt+shift+enter

package com.peihj.interfacedemo;

public class Pingpangman implements SportMan,Law,people {

    private String name;

    public Pingpangman(String name) {
        this.name = name;
    }

    @Override
    public void rule() {
        System.out.println(name+"要遵纪守法");
    }

    @Override
    public void run() {
        System.out.println(name+"必须跑步训练");
    }

    @Override
    public void competition() {
        System.out.println(name+"要比赛");
    }

    @Override
    public void eat() {
        System.out.println(name+"要吃饭");
    }
}

package com.peihj.interfacedemo;

public class test {
    public static void main(String[] args) {
        // 接口无法创建对象
        // SportMaininterface s = new SportMaininterface();
        Pingpangman p = new Pingpangman("小王");
        p.run();
        p.rule();
        p.competition();
        p.eat();

        }
    }

结果演示

接口的用法—被实现

接口与接口的关系–多继承

我们还以上述的代码为例，将其中一个代码继承另外两个，我们看一下调用接口效果

package com.peihj.interfacedemo;

public interface SportMan extends Law,people{
    void run();
    void competition();
}

package com.peihj.interfacedemo;

public class Pingpangman implements SportMan {

    private String name;

    public Pingpangman(String name) {
        this.name = name;
    }

    @Override
    public void rule() {
        
    }

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }

    @Override
    public void eat() {

    }
}

返回值一样并不会冲突

返回值不一样冲突
规范冲突无法多继承

JDK8开始接口新增方法

参考

黑马程序员