ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

day12、面向对象进阶（包、权限修饰符、final、常量、枚举、抽象类、接口）

2021-12-23 20:32:43  阅读：136  来源： 互联网

标签：String void 修饰符 day12 println out public itheima 进阶


面向对象进阶（包、权限修饰符、final、常量、枚举、抽象类、接口）

包

请添加图片描述

package com.itheima.d1_package.demo1;

public class Animal {
}

package com.itheima.d1_package.demo1;

public class Cat {
    public void run(){
        System.out.println("猫1跑的贼溜~~");
    }
}

package com.itheima.d1_package.demo2;

public class Cat {
    public void run(){
        System.out.println("猫2跑的贼快~~");
    }
}

package com.itheima.d1_package;

public class Student {
}

package com.itheima.d1_package;


import com.itheima.d1_package.demo1.Animal;
import com.itheima.d1_package.demo1.Cat;

public class Test {
    public static void main(String[] args) {
        // 导包：相同包下的类可以直接访问。
        Student s = new Student();

        // 不同包下的类必须导包才可以使用
        Animal a = new Animal();

        // 使用默认导包的类：demo1下的cat
        Cat c1 = new Cat();
        c1.run();

        // 指定使用demo2下的Cat类
        com.itheima.d1_package.demo2.Cat c2 = new  com.itheima.d1_package.demo2.Cat();
        c2.run();
    }
}

权限修饰符

请添加图片描述

package com.itheima.d2_modifier.itcast;

public class Demo {
    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
//        f.show1(); // 私有的
        f.show2();
        f.show3();
        f.show4();
    }
}

package com.itheima.d2_modifier.itcast;

public class Fu {
    // 1.private 只能本类中访问
    private void show1() {
        System.out.println("private");
    }

    // 2.缺省：本类，同一个包下的类中。
    void show2() {
        System.out.println("缺省");
    }

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

    // 4.任何地方都可以
    public void show4() {
        System.out.println("public");
    }

    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }
}

package com.itheima.d2_modifier.itheima;


import com.itheima.d2_modifier.itcast.Fu;

public class Demo {

    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show4();
    }

}

package com.itheima.d2_modifier.itheima;


import com.itheima.d2_modifier.itcast.Fu;

public class Zi extends Fu {
    public static void main(String[] args) {
        //创建Zi的对象，测试看有哪些方法可以使用
        Zi z = new Zi();
        z.show3();
        z.show4();
    }

}

请添加图片描述

final

请添加图片描述

package com.itheima.d3_final;

/**
    目标：明白final一些基本语法知识
 */
public class Test {
    // 属于类，只加载一次，可以共享 (常量)
    public static final String schoolName = "黑马";
    public static final String schoolName2;
    static{
        schoolName2 = "传智";
        // schoolName2 = "传智"; // 第二次赋值，报错了！
    }

    // 属于对象的！ (final基本上不会用来修饰实例成员变量，没有意义！)
    private final String name = "王麻子";

    public static void main(String[] args) {
       // final修饰变量，变量有且仅能被赋值一次。
        /* 变量有几种：
           局部变量。
           成员变量。
                -- 1、静态成员变量。
                -- 2、实例成员变量。
       */
        final int age;
        age = 12;
        // age = 20; // 第二次赋值，报错了！
        System.out.println(age);

        final double rate = 3.14;

        buy(0.8);

        // schoolName = "传智"; // 第二次赋值，报错了！
        Test t = new Test();
        // t.name = "麻子"; // 第二次赋值，报错了！
        System.out.println(t.name);
    }

    public static void buy(final double z){
        // z = 0.1; // 第二次赋值，报错了！
    }
}

/**
   final修饰类 类不能被继承了
 */
//final class Animal{
//}
//class Cat extends Animal{
//}

/**
   final修饰方法，方法不能被重写
 */
class Animal{
    public final void run(){
        System.out.println("动物可以跑~~");
    }
}

class Tiger extends Animal{
//    @Override
//    public void run() {
//        System.out.println("老虎跑的贼快~~~");
//    }
}

package com.itheima.d3_final;

public class Test2 {
    public static void main(String[] args) {
        // final修饰变量的注意事项：
        // 1、final修饰基本类型变量，其数据不能再改变
        final double rate = 3.14;
        // rate = 3.15; // 第二次赋值，报错

        // 2、final修饰引用数据类型的变量，变量中存储的地址不能被改变，但是地址指向的对象内容可以改变。
        final int[] arr = {10, 20, 30};
        System.out.println(arr);
        // arr = null; // 属于第二次赋值，arr中的地址不能被改变
        arr[1] = 200;
        System.out.println(arr);
        System.out.println(arr[1]);
    }
}

常量

常量概述和基本作用

请添加图片描述

package com.itheima.d4_constant;

/**
    目标：学会常量的使用，并理解常量。
 */
public class ConstantDemo1 {
    public static final String SCHOOL_NAME = "传智集团";
    public static final String USER_NAME = "itheima";
    public static final String PASS_WORD = "123456";

    public static void main(String[] args) {
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);

        if(USER_NAME.equals("")){

        }
    }
}

常量做信息标志和分类

请添加图片描述

package com.itheima.d4_constant;

import javax.swing.*;
import java.awt.event.ActionEvent;

/**
    目标: 常量的其他作用，做信息标志和信息分类（其实也是一种配置形式）
 */
public class ConstantDemo2 {
    public static final int UP = 1; // 上
    public static final int DOWN = 2; // 上
    public static final int LEFT = 3; // 左
    public static final int RIGHT = 4; // 右

    public static void main(String[] args) {
        // 1、创建一个窗口对象（桌子）
        JFrame win = new JFrame();
        // 2、创建一个面板对象（桌布）
        JPanel panel = new JPanel();
        // 3、把桌布垫在桌子上
        win.add(panel);
        // 4、创建四个按钮对象
        JButton btn1 = new JButton("上");
        JButton btn2 = new JButton("下");
        JButton btn3 = new JButton("左");
        JButton btn4 = new JButton("右");
        // 5、把按钮对象添加到桌布上去
        panel.add(btn1);
        panel.add(btn2);
        panel.add(btn3);
        panel.add(btn4);
        // 6、显示窗口
        win.setLocationRelativeTo(null);
        win.setSize(300,400);
        win.setVisible(true);


        btn1.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                move(UP) ; // 让玛丽往上跳
            }
        });
        btn2.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                move(ConstantDemo2.DOWN) ; // 让玛丽往下跳
            }
        });
        btn3.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                move(LEFT) ; // 让玛丽往左跑
            }
        });
        btn4.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                move(RIGHT) ; // 让玛丽往右跑
            }
        });
    }

    public static void move(int flag){
        // 控制玛丽移动
        switch (flag) {
            case UP:
                System.out.println("玛丽往上飞了一下~~");
                break;
            case DOWN:
                System.out.println("玛丽往下蹲一下~~");
                break;
            case LEFT:
                System.out.println("玛丽往左跑~~");
                break;
            case RIGHT:
                System.out.println("玛丽往→跑~~");
                break;
        }
    }
}

枚举

枚举的概述

请添加图片描述

package com.itheima.d5_enum;

/**
   枚举类
 */
public enum Season {
    // 枚举的第一行必须罗列枚举类的对象名称，建议全部大写。
    SPRING, SUMMER, AUTUMN, WINTER;
}

请添加图片描述

枚举的使用场景演示

请添加图片描述

package com.itheima.d5_enum;

/**
   做信息标志和分类
 */
public enum Orientation {
    UP, DOWN, LEFT, RIGHT;
}

package com.itheima.d5_enum;

import javax.swing.*;
import java.awt.event.ActionEvent;

/**
    目标: 常量的其他作用，做信息标志和信息分类（其实也是一种配置形式）
 */
public class EnumDemo2 {
    public static void main(String[] args) {
        // 1、创建一个窗口对象（桌子）
        JFrame win = new JFrame();
        // 2、创建一个面板对象（桌布）
        JPanel panel = new JPanel();
        // 3、把桌布垫在桌子上
        win.add(panel);
        // 4、创建四个按钮对象
        JButton btn1 = new JButton("上");
        JButton btn2 = new JButton("下");
        JButton btn3 = new JButton("左");
        JButton btn4 = new JButton("右");
        // 5、把按钮对象添加到桌布上去
        panel.add(btn1);
        panel.add(btn2);
        panel.add(btn3);
        panel.add(btn4);
        // 6、显示窗口
        win.setLocationRelativeTo(null);
        win.setSize(300,400);
        win.setVisible(true);


        btn1.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                move(Orientation.UP) ; // 让玛丽往上跳
            }
        });
        btn2.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                move(Orientation.DOWN) ; // 让玛丽往下跳
            }
        });
        btn3.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                move(Orientation.LEFT) ; // 让玛丽往左跑
            }
        });
        btn4.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                move(Orientation.RIGHT) ; // 让玛丽往右跑
            }
        });
    }

    public static void move(Orientation o){
        // 控制玛丽移动
        switch (o) {
            case UP:
                System.out.println("玛丽往上飞了一下~~");
                break;
            case DOWN:
                System.out.println("玛丽往下蹲一下~~");
                break;
            case LEFT:
                System.out.println("玛丽往左跑~~");
                break;
            case RIGHT:
                System.out.println("玛丽往→跑~~");
                break;
        }
    }
}

抽象类

抽象类概述

请添加图片描述

package com.itheima.d6_abstract_class;

public abstract class Animal {
    private String name;

    public abstract void run();

    public String getName() {
        return name;
    }

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

package com.itheima.d6_abstract_class;

public class Tiger extends Animal{
    @Override
    public void run() {
        System.out.println("老虎跑的贼溜~~~~");
    }
}

package com.itheima.d6_abstract_class;

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑的也很快~~~");
    }
}

package com.itheima.d6_abstract_class;

public class Test {
    public static void main(String[] args) {
        Tiger t = new Tiger();
        t.run();

        Dog t1 = new Dog();
        t1.run();
    }
}

请添加图片描述
请添加图片描述

抽象类的案例

请添加图片描述

package com.itheima.d7_abstract_test;

/**
     抽象父类
 */
public abstract class Card {
    private String name; // 主人名称
    private double money;

    /**
      子类一定要支付的，但是每个子类支付的情况不一样，所以父类把支付定义成抽象方法，交给具体子类实现
     */
    public abstract void pay(double 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.itheima.d7_abstract_test;

/**
   金卡
 */
public class GoldCard extends Card{
    @Override
    public void pay(double money) {
        // 优惠后的金额算出来：
        double rs = money * 0.8;
        double lastMoney = getMoney() - rs;
        System.out.println(getName() + "当前账户总金额："
                + getMoney() +",当前消费了：" + rs +",消费后余额剩余：" +
                lastMoney);

        setMoney(lastMoney); // 更新账户对象余额
    }
}

package com.itheima.d7_abstract_test;

public class Test {
    public static void main(String[] args) {
        GoldCard c = new GoldCard();
        c.setMoney(10000); // 父类的
        c.setName("三石");
        c.pay(300);
        System.out.println("余额：" + c.getMoney());
    }
}

抽象类的特征、注意事项小结

请添加图片描述

package com.itheima.d8_abstract_attention;

public abstract class Animal {
    private  String name;
    public Animal(){
    }
    public abstract void run();
    public abstract void run2();

    public void eat(){

    }

    public String getName() {
        return name;
    }

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

package com.itheima.d8_abstract_attention;

public class Test {
    public static void main(String[] args) {
//        有得有失: 得到了抽象方法，失去了创建对象的能力。
       //   Animal a = new Animal();
//        抽象类为什么不能创建对象？
          // a.run();

//        类有的成员（成员变量、方法、构造器）抽象类都具备

//        抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

//        一个类继承了抽象类必须重写完抽象类的全部抽象方法，
//        否则这个类也必须定义成抽象类。

//        不能用abstract修饰变量、代码块、构造器。
    }
}

class Cat extends Animal{

    @Override
    public void run() {

    }

    @Override
    public void run2() {

    }
}

请添加图片描述

抽象类的应用知识：模板方法模式

请添加图片描述
请添加图片描述
请添加图片描述

package com.itheima.d9_abstract_template.before;

/**
  活期账户
 */
public class CurrentAccount {
    private String cardId;
    private double money;

    public CurrentAccount() {
    }

    public CurrentAccount(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    /**
     登录结算利息
     */
    public void handle(String loginName , String passWord ){
        // a.判断登录是否成功
        if("itheima".equals(loginName) && "123456".equals(passWord)){
            System.out.println("登录成功。。");
            // b.正式结算利息
            double result =  money * 0.0175; // 结算利息了
            // c.输出利息详情
            System.out.println("本账户利息是："+ result);
        }else{
            System.out.println("用户名或者密码错误了");
        }
    }


    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;
    }
}

package com.itheima.d9_abstract_template.before;

/**
    定期账户
 */
public class FixedAccount {
    private String cardId;
    private double money;

    public FixedAccount() {
    }

    public FixedAccount(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    /**
      登录结算
     */
    public void handle(String loginName , String passWord ){
        // a.判断登录是否成功
        if("itheima".equals(loginName) && "123456".equals(passWord)){
            System.out.println("登录成功。。");
            // b.正式结算利息
            double result =  money * 0.035; // 结算利息了
            if(money >= 100000){
                result += money * 0.03;
            }
            // c.输出利息详情
            System.out.println("本账户利息是："+ result);
        }else{
            System.out.println("用户名或者密码错误了");
        }
    }


    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;
    }
}

package com.itheima.d9_abstract_template.after;

public abstract class Account {
    private String cardId;
    private double money;

    public Account() {
    }

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

    /**
      模板方法
     */
    public final void handle(String loginName , String passWord ){
        // a.判断登录是否成功
        if("itheima".equals(loginName) && "123456".equals(passWord)){
            System.out.println("登录成功。。");
            // b.正式结算利息
            // 当前模板方法知道所有子类账户都要结算利息，但是具体怎么结算，模板不清楚，交给具体的子类来计算
            double result = calc();
            // c.输出利息详情
            System.out.println("本账户利息是："+ result);
        }else{
            System.out.println("用户名或者密码错误了");
        }
    }

    public abstract double calc();


    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;
    }
}

package com.itheima.d9_abstract_template.after;

/**
  活期账户
 */
public class CurrentAccount extends Account {

    public CurrentAccount(String cardId,  double money) {
        super(cardId, money);
    }

    @Override
    public double calc() {
        // b.正式结算利息
        double result =  getMoney() * 0.0175; // 结算利息了
        return result;
    }

}

package com.itheima.d9_abstract_template.after;

public class Test {
    public static void main(String[] args) {
        CurrentAccount acc = new CurrentAccount("ICBC-111", 100000);
        acc.handle("itheima", "123456");
    }
}

请添加图片描述
请添加图片描述

接口

接口概述、特点

请添加图片描述
请添加图片描述

package com.itheima.d10_interface;

/**
   接口
 */
public interface SportManInterface {
    // 接口中的成员：JDK 1.8之前只有常量 和 抽象方法
    // public static final 可以省略不写，接口默认会为你加上！
    // public static final String SCHOOL_NAME = "黑马";
    String SCHOOL_NAME = "黑马";

    // 2、抽象方法
    //  public abstract 可以省略不写，接口默认会为你加上！
    // public abstract void run();
    void run();

    // public abstract void eat();
    void eat();
}

package com.itheima.d10_interface;

public class Test {
    public static void main(String[] args) {
        // 接口不能创建对象！
        // SportManInterface s = new SportManInterface();
    }
}

接口的基本使用：被实现

请添加图片描述

package com.itheima.d11_interface_implements;

public interface Law {
    void rule(); // 遵章守法
}

package com.itheima.d11_interface_implements;

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

package com.itheima.d11_interface_implements;

/**
   实现类（子类）
 */
public class PingPongMan implements SportMan , Law{
    private String name;
    public PingPongMan(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 + "需要参加国际比赛~~");
    }
}

package com.itheima.d11_interface_implements;

public class Test {
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan("张继科");
        p.rule();
        p.run();
        p.competition();
    }
}

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

请添加图片描述

package com.itheima.d12_interface_extends;

public interface Law {
    void rule(); // 遵章守法
    void eat();
}

package com.itheima.d12_interface_extends;

public interface People {
    void eat();
}

package com.itheima.d12_interface_extends;

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

package com.itheima.d12_interface_extends;

/**
   实现类
 */
// public class BasketballMan implements Law, SportMan, People {
public class BasketballMan implements SportMan{

    @Override
    public void rule() {

    }

    @Override
    public void eat() {

    }


    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

JDK8开始接口新增方法

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

package com.itheima.d13_interface_jdk8;

public interface SportManInter {
    /**
       1、JDK 8开始 ：默认方法(实例方法)
       -- 必须default修饰，默认用public修饰
       -- 默认方法，接口不能创建对象，这个方法只能过继给了实现类，由实现类的对象调用。
     */
    default void run(){
        //go();
        System.out.println("跑的很快~~~");
    }

    /**
      2、静态方法
        必须使用static修饰，默认用public修饰
        -- 接口的静态方法，必须接口名自己调用。
     */
    static void inAddr(){
        System.out.println("我们都在学习Java新增方法的语法，它是Java源码自己会用到的~~~");
    }

    /**
       3、私有方法（实例方法）
         -- JDK 1.9开始才支持的。
         -- 必须在接口内部才能被访问
     */
    //void go(){
       // System.out.println("开始跑~~~");
    //}

}

class PingPongMan implements SportManInter{
}

class Test{
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan();
        p.run();


        SportManInter.inAddr();
        // PingPongMan.inAddr();
    }
}

请添加图片描述

使用接口的注意事项【了解】请添加图片描述

package com.itheima.d14_interface_attention;

public class Test {
    public static void main(String[] args) {
//        1、接口不能创建对象(接口更加彻底的抽象)

//        2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。


//        3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
            Cat c = new Cat();
            c.eat();
//        4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。

//        5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。

    }
}

//   5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
//interface AAA{
//    int run();
//}
//interface BBB{
//    void run();
//}
//
//interface CCC extends AAA, BBB{
//}

//   4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
interface AA{
    default void go(){
        System.out.println("AA");
    }
}
interface BB{
    default void go(){
        System.out.println("BB");
    }
}
class CC implements AA, BB{
    @Override
    public void go() {
    }
}



// 3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
interface Food{
    default void eat(){
        System.out.println("接口中的吃方法~~");
    }
}
class Animal{
    public void eat(){
        System.out.println("父类动物吃~~");
    }
}
class Cat extends Animal implements Food {
}



interface A{
    static void test(){
        System.out.println("A");
    }
}

interface B{
    static void test(){
        System.out.println("B");
    }
}
/**
 2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。 原因是接口的静态方法不能C调用，只能A调用A的  只能B调用B的
 */
class C implements A,B{

}

标签：String,void,修饰符,day12,println,out,public,itheima,进阶
来源： https://blog.csdn.net/wjl200212/article/details/122061573

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有