java 面向对象高级1

1.final关键字

1. class Demo{
2.     public static void main(String[] args) {
3.         final int[] a=new int[]{1,2,3};
4.        // a=new int[]{4,5,6};  报错
5.         a[0]=5;//可以，解释了final修饰引用性变量，变量存储的地址不能被改变，但地址所指向的对象的内容可以改变
6.     }
7. }

复制代码

什么是常量？

2.单例计划模式-懒汉式单例-饿汉式单例

3.罗列类

1. //常规写法
2. class Constant{
3.     public static final int UP=0;
4.     public static final int DOWN=1;
5.     public static final int LEFT=2;
6.     public static final int RIGHT=3;
7. }
8. class Demo{
9.     public static void move(int direction){
10.         switch (direction){
11.             case Constant.UP:
12.                 System.out.println("向上移动");
13.                 break;
14.             case Constant.DOWN:
15.                 System.out.println("向下移动");
16.                 break;
17.             case Constant.LEFT:
18.                 System.out.println("向左移动");
19.                 break;
20.             case Constant.RIGHT:
21.                 System.out.println("向右移动");
22.                 break;
23.             default:
24.                 System.out.println("无效方向");
25.         }
26.     }
27. }
28. //枚举类写法，相较于常规的好处是
29. /*类型安全：枚举提供了更好的类型安全，因为它们限制了变量只能取预定义的值，而常规的静态常量类则没有这种限制。
30. 可读性：枚举通常更易于阅读和理解，因为它们使用名称而不是数字或字符串来表示常量值。
31. 维护性：使用枚举可以更容易地管理和维护一组相关的常量值，因为它们是集中定义的。
32. 功能扩展：枚举可以有自己的方法和属性，这为扩展功能提供了可能，而常规的静态常量类则没有这样的能力。*/
33. enum Direction{
34.     UP,DOWN,LEFT,RIGHT
35. }
36. class Demo2{
37.     public static void move(Direction direction){
38.         switch (direction){
39.             case UP:
40.                 System.out.println("向上移动");
41.                 break;
42.             case DOWN:
43.                 System.out.println("向下移动");
44.                 break;
45.             case LEFT:
46.                 System.out.println("向左移动");
47.                 break;
48.             case RIGHT:
49.                 System.out.println("向右移动");
50.                 break;
51.         }
52.     }
53. }

复制代码

4.认识抽象类

5.模板方法计划模式

1. class A extends fu{
2.     public void writemain(){
3.         System.out.println("特殊方法A");
4.     }
5. }
6. class B extends fu{
7.     public void writemain(){
8.         System.out.println("特殊方法B");
9.     }
10. }
11. abstract class fu{
12.     public final void write(){
13.         System.out.println("公用方法1");
14.         writemain();
15.         System.out.println("公用方法2");
16.     }
17.     public abstract void writemain();
18. }
19. class Demo{
20.     public static void main(String[] args) {
21.         fu a=new A();
22.         a.write();
23.     }
24. }
25. /*
26. 输出：
27. 公用方法1
28. 特殊方法A
29. 公用方法2
30. */

复制代码

1. // 抽象类：饮料制作
2. abstract class BeverageMaker {
3.     // 模板方法，定义了制作饮料的算法骨架
4.     public final void makeBeverage() {
5.         boilWater();
6.         brew();
7.         pourInCup();
8.         if (customerWantsCondiments()) {
9.             addCondiments();
10.         }
11.     }
13.     // 具体方法：烧水，属于算法中的固定部分
14.     private void boilWater() {
15.         System.out.println("Boiling water");
16.     }
18.     // 抽象方法：冲泡，属于算法中的可变部分
19.     protected abstract void brew();
21.     // 具体方法：倒入杯子，属于算法中的固定部分
22.     private void pourInCup() {
23.         System.out.println("Pouring into cup");
24.     }
26.     // 钩子方法：是否添加调料，子类可以重写该方法来决定是否添加调料
27.     protected boolean customerWantsCondiments() {
28.         return true;
29.     }
31.     // 抽象方法：添加调料，属于算法中的可变部分
32.     protected abstract void addCondiments();
33. }
35. // 具体子类：制作咖啡
36. class CoffeeMaker extends BeverageMaker {
37.     @Override
38.     protected void brew() {
39.         System.out.println("Dripping coffee through filter");
40.     }
42.     @Override
43.     protected void addCondiments() {
44.         System.out.println("Adding sugar and milk");
45.     }
47.     // 重写钩子方法，决定是否添加调料
48.     @Override
49.     protected boolean customerWantsCondiments() {
50.         return false;
51.     }
52. }
54. // 具体子类：制作茶
55. class TeaMaker extends BeverageMaker {
56.     @Override
57.     protected void brew() {
58.         System.out.println("Steeping the tea");
59.     }
61.     @Override
62.     protected void addCondiments() {
63.         System.out.println("Adding lemon");
64.     }
65. }
67. // 测试类
68. public class TemplateMethodPatternDemo {
69.     public static void main(String[] args) {
70.         // 制作咖啡
71.         BeverageMaker coffeeMaker = new CoffeeMaker();
72.         coffeeMaker.makeBeverage();
74.         System.out.println();
76.         // 制作茶
77.         BeverageMaker teaMaker = new TeaMaker();
78.         teaMaker.makeBeverage();
79.     }
80. }

复制代码

6.认识接口

1. //jdk 8之前，接口中只能定义常量和抽象方法
2. //接口不能创建对象
3. public interface A {
4.     String STUDENT_NAME="li hua"; //接口中默认加上 public static final
5.     // 等价于 public static final String STUDENT_NAME="li hua";
6.     void run();//接口中给方法默认加上public abstract
7.     //等价于 public abstract void run();
8. }
10. //Demo被称为实现类，可以同时实现多个接口，
11. //实现类实现多个接口必须重写全部抽象方法，否则必须定义成抽象类
12. public class Demo implements A{
13.     @Override
14.     public void run() {
15.     }
16. }

复制代码

1. public class Demo{
2.     public static void main(String[] args) {
3.         people p=new student();
4.         doctor d=new student();
5.         driver dr=new student();
6.     }
7. }
8. interface driver{}
9. interface doctor{}
10. class student extends people implements driver,doctor{}
11. class people{}

复制代码

---

1. public class Demo {
2.     public static void main(String[] args) {
3.         people p = new student();
4.         doctor d = new student();
5.         driver dr = new student();
6.     }
7. }
9. interface driver {}
10. interface doctor {}
11. class student extends people implements driver, doctor {}
12. class people {}

复制代码

多态表现：

• 向上转型（多态的根本）：
  
  
  
  • people p = new student();
    
  • doctor d = new student();
    
  • driver dr = new student();
    
  这里 student 对象被赋值给了父类 people 和两个接口 doctor、driver 的引用变量。这种举动是向上转型，即子类对象可以被赋值给父类或接口范例的引用。
  
  
• 多态的本质：
  
  
  
  • 多态的本质是：父类或接口的引用可以指向子类对象。在运行时，通过这些父类或接口的引用，可以调用子类的重写方法（假如有）。这种计划使得代码更加机动，可以大概通过同一的父类或接口来处置处罚差异的子类对象。
    
  
  
• 接口多态：
  
  
  
  • 这里 student 实现了两个接口：doctor 和 driver。通过利用接口作为引用范例（doctor d 和 driver dr），可以将 student 的对象赋值给这些接口变量。这种计划使得 student 可以被看作是一名医生（doctor）大概司机（driver），从而实现了接口层面的多态。
    
  
  

---

第二段代码的多态表现

1. class animals {
2.     String name = "animals";
3.     public void run() {}
4. }
6. class cat extends animals {
7.     String name = "cat";
8.     @Override
9.     public void run() {
10.         System.out.println("cat run");
11.     }
12. }
14. class dog extends animals {
15.     String name = "dog";
16.     @Override
17.     public void run() {
18.         System.out.println("dog run");
19.     }
20. }
22. class demo {
23.     public static void main(String[] args) {
24.         animals a = new cat();
25.         a.run();
26.         animals b = new dog();
27.         b.run();
28.         System.out.println(a.name);
29.         System.out.println(b.name); // 成员变量不具有多态性
30.     }
31. }

复制代码

多态表现：

• 向上转型（多态的根本）：
  
  
  
  • animals a = new cat();
    
  • animals b = new dog();
    
  子类 cat 和 dog 的对象被赋值给父类 animals 的引用变量 a 和 b。这也是向上转型，即用父类范例的引用来指向子类对象。
  
  
• 动态绑定（运行时多态）：
  
  
  
  • 调用 a.run() 和 b.run() 时，实际上调用的是子类 cat 和 dog 的 run 方法，而不是父类 animals 的 run 方法。这是由于方法调用是动态绑定的，即在运行时根据对象的实际范例（cat 或 dog）来决定调用哪个方法。
    
  • 输出效果：
    1. cat run
    2. dog run

    复制代码
  
  
• 成员变量不具有多态性：
  
  
  
  • 当访问成员变量 a.name 和 b.name 时，输出的是父类 animals 的 name 属性值，而不是子类 cat 或 dog 的 name 属性值。这是由于成员变量的访问是编译时绑定的，取决于引用变量的范例（这里是父类 animals）。
    
  • 输出效果：
    1. animals
    2. animals

    复制代码
  
  

---

两段代码的多态对比

特性第一段代码第二段代码多态的实现方式通过接口和父类的引用指向子类对象，表现了接口多态和继续多态。通过父类引用指向子类对象，表现了继续多态。动态绑定没有方法调用的详细实现，未展示动态绑定的效果。通过调用重写的 run 方法，展示了动态绑定的效果。成员变量的多态性未涉及成员变量的多态性题目。明确指出成员变量不具有多态性，访问的是父类的成员变量值。接口的利用利用了接口 doctor 和 driver，表现了接口多态。未利用接口，完全基于继续实现多态。代码计划的机动性通过接口可以让 student 以差异的身份（doctor 或 driver）存在，机动性更高。通过继续实现了差异子类的举动差异，但不涉及接口的机动性。

---

总结

• 第一段代码紧张通过接口和继续的组合来表现多态，展示了对象可以以多种身份存在（people、doctor、driver），夸大了接口多态的机动性。
  
• 第二段代码紧张通过继续和方法的重写来表现多态，展示了运行时的动态绑定（方法调用的多态性）以及成员变量不具有多态性的特点。
  

两段代码各自侧重多态的差异方面，共同表现了多态在 Java 中的紧张性和机动性。
接口的应用案例

1. import lombok.AllArgsConstructor;
2. import lombok.Data;
3. import lombok.NoArgsConstructor;
5. public class Demo{
6.     public static void main(String[] args) {
7.         student[] s=new student[3];
8.         s[0]=new student("li hua","boy",90);
9.         s[1]=new student("zhang san","boy",100);
10.         s[2]=new student("tu xin yue","girl",95);
11.         tool t=new imp2(s);
12.         t.listallinfo();
13.         t.sumscore();
14.     }
15. }
17. class student{
18.     private String name;
19.     private String sex;
20.     private double score;
22.     public student(String name, String sex, double score) {
23.         this.name = name;
24.         this.sex = sex;
25.         this.score = score;
26.     }
27.     public student(){}
28.     public String getName() {
29.         return name;
30.     }
32.     public void setName(String name) {
33.         this.name = name;
34.     }
36.     public String getSex() {
37.         return sex;
38.     }
40.     public void setSex(String sex) {
41.         this.sex = sex;
42.     }
44.     public double getScore() {
45.         return score;
46.     }
48.     public void setScore(double score) {
49.         this.score = score;
50.     }
51. }
52. interface tool{
53.     public void listallinfo();
54.     public void sumscore();
55. }
56. class imp1 implements tool{
57.     private student[] s;  
58.     public imp1(student[] s){    //一般建议利用有参构造方法，推荐这种形式
59.         this.s=s;
60.     }
61.     @Override
62.     public void listallinfo() {
63.         for(int i=0;i<s.length;i++){
64.             System.out.println(s[i].getName()+" "+s[i].getSex()+" "+s[i].getScore());
65.         }
66.     }
68.     @Override
69.     public void sumscore() {
70.         double sum=0;
71.         for(int i=0;i<s.length;i++){
72.             sum+=s[i].getScore();
73.         }
74.         System.out.println(sum/s.length);
75.     }
76. }
77. class imp2 implements tool{
78.     private student[] s;
79.     public imp2(student[] s){
80.         this.s=s;
81.     }
82.     @Override
83.     public void listallinfo() {
84.         int flag=0;
85.         for(int i=0;i<s.length;i++){
86.             System.out.println(s[i].getName()+" "+s[i].getSex()+" "+s[i].getScore());
87.             if(s[i].getSex()=="boy"){
88.                 flag++;
89.             }
90.         }
91.         System.out.println("男生人数:"+flag+"女生人数:"+(s.length-flag));
92.     }
94.     @Override
95.     public void sumscore() {
96.         double max=s[0].getScore();
97.         double min=s[0].getScore();
98.         double sum=0;
99.         for(int i=0;i<s.length;i++){
100.             sum+=s[i].getScore();
101.             if(max<s[i].getScore()){
102.                 max=s[i].getScore();
103.             }
104.             if(min>s[i].getScore()){
105.                 min=s[i].getScore();
106.             }
107.         }
108.         System.out.println("去掉一个最高分和最低分后的平均分为"+(sum-max-min)/(s.length-2));
109.     }
110. }

复制代码

7.JDK8开始，接口新增的三种方法

1. public class Demo{
2.     public static void main(String[] args) {
3.         A a=new impA();
4.         a.run();
5.         A.show();
6.     }
7. }
8. class impA implements A{}
9. interface A{
10.     //1.大部分情况下，接口只能写抽象方法，jdk8之后，可以写普通实例方法了，但必须加default修饰
11.     //默认用public修饰
12.     //但是接口不能构建对象，应该怎么调用该方法？利用接口的实现类的对象来调用
13.     default void run(){
14.         System.out.println("--run--");
15.         go();
16.     }
17.     //2.jdk9开始支持私有方法，他是私有的，利用接口的实现类的对象也不能调用了，只能使用接口中的其他实例方法来调用
18.     private void go(){
19.         System.out.println("--go--");
20.     }
21.     //3.静态方法，默认用public方法，如何调用？只能通过接口名字直接调用
22.     static void show(){
23.         System.out.println("--show--");
24.     }
25. }

复制代码

8.接口的留意事项

1. //
2. public class Demo{
3.     public static void main(String[] args) {
4.         
5.     }
6. }
7. class D implements C{
8.     @Override
9.     public void show3() {}
10.     @Override
11.     public void show1() {}
12.     @Override
13.     public void show2() {}
14. }
15. interface A{
16.     void show1();
17. }
18. interface B{
19.     void show2();
20. }
21. interface C extends A,B{
22.     void show3();
23. }

复制代码

9.抽象类和接口的区别

雷同点：
1.都是抽象情势，都可以抽象方法，都不能创建对象
2.都是派生子类情势，抽象类是被子类继续利用，接口是被实现类实现
3.一个类继续抽象类，大概实现接口，都必须重写玩他们的抽象方法，否则本身要成为抽象类否则会报错
4.都能支持多态，都能实现解耦合
差异点：
1.抽象类可以界说类的全部平凡成员，接口只能界说常量和抽象方法（以及JDK8以后的三种新方法）
2.抽象类只能被类单继续，接口可以被类多实现
3.一个类继续抽象类就不能再继续别的类，一个类实现了接口还可以继续其他类或实现其他接口
4.抽象类表现模板头脑，更利于做父类，实当代码的复用性
5.接口更得当做功能的解耦合，解耦合性更强更机动。
6.计划目的
抽象类
紧张用于代码复用和提供一个通用的模板。它表现了一种 “is - a” 的关系，即子类是一种特殊的抽象类。比方，Dog是一种Animal，Dog类可以继续Animal抽象类，复用Animal类中的属性和方法，同时实现本身特有的举动（如makeSound()方法实现狗叫）。
接口
用于界说举动规范，实现接口的类必须依照这个规范。它表现了一种 “can - do” 的关系，即类可以做接口界说的变乱。比方，假如一个类实现了Flyable接口，就表现这个类可以飞行，不管这个类是Bird照旧Airplane，只要实现了Flyable接口，就必须实现fly()方法来界说飞行的举动。
10.一个案例

1. import java.util.Scanner;
3. public class Demo{
4.     public static void main(String[] args) {
5.         JD[] jd=new JD[3];
6.         jd[0]=new Air("空调",true);
7.         jd[1]=new TV("电视",false);
8.         jd[2]=new Lamp("灯",false);
9.         while(true) {
10.             Control c = Control.getControl();
11.             c.dolist(jd);
12.             System.out.println("输入要控制的编号");
13.             Scanner sc = new Scanner(System.in);
14.             int tmp = sc.nextInt();
15.             if(tmp==0){
16.                 return;
17.             }
18.             c.dopress(jd[tmp - 1]);
19.         }
20.     }
21. }
22. class JD implements modif{
23.     private String name;
24.     private boolean status;
26.     public JD(String name, boolean status) {
27.         this.name = name;
28.         this.status = status;
29.     }
31.     public JD(){}
32.     public String getName() {
33.         return name;
34.     }
35.     public void setName(String name) {
36.         this.name = name;
37.     }
38.     public boolean isStatus() {
39.         return status;
40.     }
41.     public void setStatus(boolean status) {
42.         this.status = status;
43.     }
45.     @Override
46.     public void press() {
47.         this.status=!status;
48.     }
49. }
50. class Lamp extends JD{
51.     public Lamp(String name,boolean status){
52.         super(name,status);
53.     }
54. }
55. class TV extends JD{
56.     public TV(String name,boolean status){
57.         super(name,status);
58.     }
59. }
60. class Air extends JD{
61.     public Air(String name,boolean status){
62.         super(name,status);
63.     }
64. }
65. interface modif{
66.     void press();
67. }
68. class Control {
69.     private Control(){}
70.     private static Control c=new Control();
71.     public static Control getControl(){
72.         return c;
73.     }
74.     public void dolist(JD[] jd){
75.         for(int i=0;i< jd.length;i++){
76.             System.out.println((i+1)+"号为"+jd[i].getName()+",当前状态为"+jd[i].isStatus());
77.         }
78.     }
79.     public void dopress(JD jd){
80.         System.out.println(jd.getName()+"当前状态为"+((jd.isStatus()==true)?"开":"关"));
81.         jd.setStatus(!jd.isStatus());
82.         System.out.println(jd.getName()+"当前状态为"+((jd.isStatus()==true)?"开":"关"));
83.     }
84. }

复制代码