面向对象进阶（包、权限修饰符、final、常量、枚举、抽象类、接口）
包权限修饰符final常量常量概述和基本作用常量做信息标志和分类枚举枚举的概述枚举的使用场景演示抽象类抽象类概述抽象类的案例抽象类的特征、注意事项小结抽象类的应用知识：模板方法模式接口接口概述、特点接口的基本使用：被实现接口与接口的关系：多继承JDK8开始接口新增方法使用接口的注意事项【了解】![请添加图片描述])包
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下的catCat 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() {@Overridepublic void actionPerformed(ActionEvent e) {move(UP) ; // 让玛丽往上跳}});btn2.addActionListener(new AbstractAction() {@Overridepublic void actionPerformed(ActionEvent e) {move(ConstantDemo2.DOWN) ; // 让玛丽往下跳}});btn3.addActionListener(new AbstractAction() {@Overridepublic void actionPerformed(ActionEvent e) {move(LEFT) ; // 让玛丽往左跑}});btn4.addActionListener(new AbstractAction() {@Overridepublic 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() {@Overridepublic void actionPerformed(ActionEvent e) {move(Orientation.UP) ; // 让玛丽往上跳}});btn2.addActionListener(new AbstractAction() {@Overridepublic void actionPerformed(ActionEvent e) {move(Orientation.DOWN) ; // 让玛丽往下跳}});btn3.addActionListener(new AbstractAction() {@Overridepublic void actionPerformed(ActionEvent e) {move(Orientation.LEFT) ; // 让玛丽往左跑}});btn4.addActionListener(new AbstractAction() {@Overridepublic 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{@Overridepublic void run() {System.out.println("老虎跑的贼溜~~~~");}}
package com.itheima.d6_abstract_class;public class Dog extends Animal{@Overridepublic 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{@Overridepublic 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{@Overridepublic void run() {}@Overridepublic 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);}@Overridepublic 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;}@Overridepublic void rule() {System.out.println(name + "要遵章守法，不能随意外出，酗酒，约会~~~");}@Overridepublic void run() {System.out.println(name + "必须要跑步训练~~");}@Overridepublic 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();petition();}}
接口与接口的关系：多继承
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{@Overridepublic void rule() {}@Overridepublic void eat() {}@Overridepublic void run() {}@Overridepublic 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{@Overridepublic 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{}
