[零基础学JAVA]Java SE面向对象部分-17.面向对象高级（05）

最新推荐文章于 2024-09-08 10:40:56 发布
最新推荐文章于 2024-09-08 10:40:56 发布
阅读量111 收藏
点赞数
文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33711641/article/details/85142525
版权
上季内容回顾：
1、对象的多态性
2、抽象类和接口
本季主要知识点：
抽象类和接口的实际应用
1、子类对象可以为父类对象实例化，之后调用的方法都是子类中已经被覆写过的方法。
2、就可以利用此特性，观察抽象类的使用，因为在抽象类中有很多的抽象方法。
抽象类
abstract class A    
{    
         public abstract void fun();    
};    
class B extends A    
{    
         public void fun()    
        {    
                System.out.println( "B ==> Hello World");    
        }    
};    
class C extends A    
{    
         public void fun()    
        {    
                System.out.println( "C ==> Hello World");    
        }    
};    
public class Demo01    
{    
         public static void main(String args[])    
        {    
                A a = new B();    
                a.fun();    
        }    
};
image
abstract class A    
{    
         public abstract void fun();    
};    
class B extends A    
{    
         public void fun()    
        {    
                System.out.println( "B ==> Hello World");    
        }    
};    
class C extends A    
{    
         public void fun()    
        {    
                System.out.println( "C ==> Hello World");    
        }    
};    
public class Demo01    
{    
         public static void main(String args[])    
        {    
                A a = new C();    
                a.fun();    
        }    
};
image
抽象类是可以实例化的，通过对象的多态性来实例化
抽象类的主要作用是什么呢？抽象类就是类似于一个模板操作 ==>JAVA WEB Servlet程序，提供的就是一个模板。
image
把上面的实际的例子变为程序
abstract class Err    
{    
         public void printInfo()    
        {    
                System.out.println( "姓名："+ this.getName());    
                System.out.println( "班级："+ this.getCls());    
                System.out.println( "事由："+ this.getCau());    
        }    
         //得到姓名，由具体的子类去做    
         public abstract String getName();    
         //得到班级，由具体的子类去做    
         public abstract String getCls();    
         //得到事由    
         public abstract String getCau();    
}    
class ZhangSan extends Err    
{    
         public String getName()    
        {    
                 return "张三";    
        }    
         public String getCls()    
        {    
                 return "小五班";    
        }    
         public String getCau()    
        {    
                 return "因为上课吃东西，所以被老师抓住了，所以要填写违纪卡。 ";    
        }    
}    
class LiSi extends Err    
{    
         public String getName()    
        {    
                 return "李四";    
        }    
         public String getCls()    
        {    
                 return "大五班";    
        }    
         public String getCau()    
        {    
                 return "因为上课睡觉，所以被老师抓住了，所以要填写违纪卡。 ";    
        }    
}    
public class Demo02    
{    
         public static void main(String args[])    
        {    
                Err e = new ZhangSan();    
                e.printInfo();    
        }    
}
image
我们改成李四看看效果哈~
abstract class Err    
{    
         public void printInfo()    
        {    
                System.out.println( "姓名："+ this.getName());    
                System.out.println( "班级："+ this.getCls());    
                System.out.println( "事由："+ this.getCau());    
        }    
         //得到姓名，由具体的子类去做    
         public abstract String getName();    
         //得到班级，由具体的子类去做    
         public abstract String getCls();    
         //得到事由    
         public abstract String getCau();    
}    
class ZhangSan extends Err    
{    
         public String getName()    
        {    
                 return "张三";    
        }    
         public String getCls()    
        {    
                 return "小五班";    
        }    
         public String getCau()    
        {    
                 return "因为上课吃东西，所以被老师抓住了，所以要填写违纪卡。 ";    
        }    
}    
class LiSi extends Err    
{    
         public String getName()    
        {    
                 return "李四";    
        }    
         public String getCls()    
        {    
                 return "大五班";    
        }    
         public String getCau()    
        {    
                 return "因为上课睡觉，所以被老师抓住了，所以要填写违纪卡。 ";    
        }    
}    
public class Demo02    
{    
         public static void main(String args[])    
        {    
                Err e = new LiSi();    
                e.printInfo();    
        }    
}
调用模板成功了哈~
image 
（模板设计）场景：
       假设Person分为Worker和Student，工人的属性包括：姓名、年龄、工资，学生的属性包括：姓名、年龄、成绩，那么现在人都可以说话，但是工人和学生说的话肯定不一样。此时，肯定人中的说话方法是固定的，肯定是一个普通方法，只是说话的内容不一样。
abstract class Person    
{    
         private String name;    
         private int age;    
         public Person(String name, int age)    
        {    
                 this.name = name;    
                 this.age = age;    
        }    
         public String getName()    
        {    
                 return this.name;    
        }    
         public int getAge()    
        {    
                 return this.age;    
        }    
         public void talk()    
        {    
                 //这是要说，内容都在此方法中    
                System.out.println( this.getContent());    
        }    
         public abstract String getContent();    
}    
class Student extends Person    
{    
         private float score;    
         public Student(String name, int age, float score)    
        {    
                 super(name,age);    
                 this.score = score;    
        }    
         public String getContent()    
        {    
                 return "学生说 --> 姓名="+ super.getName()    
                                + "，年龄="+ super.getAge()    
                                + "，成绩="+ this.score;    
        }    
}    
class Worker extends Person    
{    
         private float salary;    
         public Worker(String name, int age, float salary)    
        {    
                 super(name,age);    
                 this.salary = salary;    
        }    
         public String getContent()    
        {    
                 return "工人说 --> 姓名="+ super.getName()    
                                + "，年龄="+ super.getAge()    
                                + "，工资="+ this.salary;    
        }    
}    
public class Demo03    
{    
         public static void main(String args[])    
        {    
                Person p1 = new Student( "张三",20,90.0f);    
                Person p2 = new Worker( "李四",30,900.0f);    
                p1.talk();    
                p2.talk();    
        }    
}
image
接口的实际应用
image
分布式代码中最重要的就是要规定好操作的接口。接口就是定义了一个标准，只要按照此标准代码都可以正常使用。
interface A    
{    
         public String getInfo();    
}    
class B implements A    
{    
         public String getInfo()    
        {    
                 return "B --> Hello World";    
        }    
}    
class C implements A    
{    
         public String getInfo()    
        {    
                 return "C --> Hello World";    
        }    
}    
public class Demo04    
{    
         public static void main(String args[])    
        {    
                A a = new B();    
                System.out.println(a.getInfo());    
        }    
}
证明接口对象可以实例化，通过对象多态性进行向上转型，接口是可以实例化的。
image
我们改成C看看效果
interface A    
{    
         public String getInfo();    
}    
class B implements A    
{    
         public String getInfo()    
        {    
                 return "B --> Hello World";    
        }    
}    
class C implements A    
{    
         public String getInfo()    
        {    
                 return "C --> Hello World";    
        }    
}    
public class Demo04    
{    
         public static void main(String args[])    
        {    
                A a = new C();    
                System.out.println(a.getInfo());    
        }    
}
我们发现都可以利用对象多态性完成操作
image
接口是一个标准。
  USB接口  --> 只要是实现了USB接口的设备就都可以向USB接口上插。
举例：
  假设现在设计一个USB接口，里面只有开始工作和停止工作的操作。主板上有USB接口，表示可以插入任意的USB设备。
interface USB    
{    
         //表示开始工作    
         public void start();    
         //表示停止工作    
         public void stop();    
}    
class MainBoard    
{    
         //只要是USB设备就可以插    
         public static void plugIn(USB usb)    
        {    
                usb.start();    
                usb.stop();    
        }    
}    
class MP3 implements USB    
{    
         public void start()    
        {    
                System.out.println( "MP3开始工作");    
        }    
         public void stop()    
        {    
                System.out.println( "MP3停止工作");    
        }    
}    
class Print implements USB    
{    
         public void start()    
        {    
                System.out.println( "打印机开始工作");    
        }    
         public void stop()    
        {    
                System.out.println( "打印机停止工作");    
        }    
}    
public class Demo05    
{    
         public static void main(String args[])    
        {    
                USB u = new MP3();    
                MainBoard.plugIn(u);    
        }    
}
现在看下效果
image
如果是打印机呢？
interface USB    
{    
         //表示开始工作    
         public void start();    
         //表示停止工作    
         public void stop();    
}    
class MainBoard    
{    
         //只要是USB设备就可以插    
         public static void plugIn(USB usb)    
        {    
                usb.start();    
                usb.stop();    
        }    
}    
class MP3 implements USB    
{    
         public void start()    
        {    
                System.out.println( "MP3开始工作");    
        }    
         public void stop()    
        {    
                System.out.println( "MP3停止工作");    
        }    
}    
class Print implements USB    
{    
         public void start()    
        {    
                System.out.println( "打印机开始工作");    
        }    
         public void stop()    
        {    
                System.out.println( "打印机停止工作");    
        }    
}    
public class Demo05    
{    
         public static void main(String args[])    
        {    
                USB u = new Print();    
                MainBoard.plugIn(u);    
        }    
}
image
这就是一个典型的操作，一切以接口标准进行操作。接口规定什么，其就可以完成什么样的工作哈~
举例：
  听我讲课，听我讲课，我说的是中文，你听的是中文，所以你能听懂，如果你再说话，你肯定也说中文，我听的也是中文。
接口在实际中可以作为一种标准，那么这种标准在使用的时候就可以让类之间进行解耦合操作。
  接口的重要目的是解耦合：   A --> B
class A    
{    
         public void fun(B b)    
        {    
                b.print();    
        }    
}    
class B    
{    
         public void print()    
        {    
                System.out.println( "Hello World!!!");    
        }    
}    
public class Demo06    
{    
         public static void main(String args[])    
        {    
                 new A().fun( new B());    
        }    
}
image
此代码存在的问题：
  如果现在B类的功能不能直接满足A类的要求了， 需要对B进行扩充或是把B类彻底替换成另外一个C类，那么此时要完成以下步骤：修改A类、增加C类，那么问有没有这样一种可能：修改功能的时候我可以不动类A呢？可以使用接口。
class A    
{    
         public void fun(X x)    
        {    
                x.print();    
        }    
}    
interface X    
{    
         public void print();    
}    
class B implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello World!!!");    
        }    
}    
class C implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello Java!!!");    
        }    
}    
public class Demo06    
{    
         public static void main(String args[])    
        {    
                X x = new C();    
                 new A().fun(x);    
        }    
}
image
问题：
  在实际的代码中main方法实际上应该是作为一个客户端出现的。
此时客户端与接口和其接口的子类是直接有关的。代码中肯定不能这样编写，因为会造成客户端（main）与具体的子类耦合。
  JVM的工作原理：
*.class -->JVM -->OS ：程序可移植性高。
class A    
{    
         public void fun(X x)    
        {    
                x.print();    
        }    
}    
interface X    
{    
         public void print();    
}    
class B implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello World!!!");    
        }    
}    
class C implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello Java!!!");    
        }    
}    
//中间再加入一个过渡端    
class Factory    
{    
         public static X getInstance(String str)    
        {    
                X x = null;    
                 if ( "B".equals(str))    
                {    
                         //认为操作的是B类    
                        x = new B();    
                }    
                 if ( "C".equals(str))    
                {    
                        x = new C();    
                }    
                 return x;    
        }    
}    
public class Demo06    
{    
         public static void main(String args[])    
        {    
                X x = Factory.getInstance( "B");    
                 new A().fun(x);    
        }    
}
现在在客户端就看不到接口了
image
现在换成C标记
class A    
{    
         public void fun(X x)    
        {    
                x.print();    
        }    
}    
interface X    
{    
         public void print();    
}    
class B implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello World!!!");    
        }    
}    
class C implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello Java!!!");    
        }    
}    
//中间再加入一个过渡端    
class Factory    
{    
         public static X getInstance(String str)    
        {    
                X x = null;    
                 if ( "B".equals(str))    
                {    
                         //认为操作的是B类    
                        x = new B();    
                }    
                 if ( "C".equals(str))    
                {    
                        x = new C();    
                }    
                 return x;    
        }    
}    
public class Demo06    
{    
         public static void main(String args[])    
        {    
                X x = Factory.getInstance( "C");    
                 new A().fun(x);    
        }    
}
image
此时客户端并没有一个具体的子类出现。
class A    
{    
         public void fun(X x)    
        {    
                x.print();    
        }    
}    
interface X    
{    
         public void print();    
}    
class B implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello World!!!");    
        }    
}    
class C implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello Java!!!");    
        }    
}    
//中间再加入一个过渡端    
class Factory    
{    
         public static X getInstance(String str)    
        {    
                X x = null;    
                 if ( "B".equals(str))    
                {    
                         //认为操作的是B类    
                        x = new B();    
                }    
                 if ( "C".equals(str))    
                {    
                        x = new C();    
                }    
                 return x;    
        }    
}    
public class Demo06    
{    
         public static void main(String args[])    
        {    
                 if (args.length!=1)    
                {    
                        System.out.println( "程序参数错误，程序无法运行！");    
                        System.exit(1);    
                }    
                X x = Factory.getInstance(args[0]);    
                 new A().fun(x);    
        }    
}
image
  以后如果假设要增加新的子类的时候，只需要修改工厂类即可，其他地方不用做太大的修改，即：
某一个代码的修改不影响被调用处的代码就是好的设计。
上面的例子中执行java Demo06 D出现NullPointerException错误，我们可以这样修改，加个判断 if(x!=null)。
class A    
{    
         public void fun(X x)    
        {    
                 if(x!= null)    
                x.print();    
        }    
}    
interface X    
{    
         public void print();    
}    
class B implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello World!!!");    
        }    
}    
class C implements X    
{    
         public void print()    
        {    
                System.out.println( "Hello Java!!!");    
        }    
}    
//中间再加入一个过渡端    
class Factory    
{    
         public static X getInstance(String str)    
        {    
                X x = null;    
                 if ( "B".equals(str))    
                {    
                         //认为操作的是B类    
                        x = new B();    
                }    
                 if ( "C".equals(str))    
                {    
                        x = new C();    
                }    
                 return x;    
        }    
}    
public class Demo06    
{    
         public static void main(String args[])    
        {    
                 if (args.length!=1)    
                {    
                        System.out.println( "程序参数错误，程序无法运行！");    
                        System.exit(1);    
                }    
                X x = Factory.getInstance(args[0]);    
                 new A().fun(x);    
        }    
}
image
  最早：接口直接去通过new 子类取得对象，那么这样造成一个接口与具体的子类直接耦合
  现在：接口通过一个工厂类取得子类对象（根据传入的参数不同），此时接口与具体子类之间没有直接的耦合关系，所以使用接口可以解耦合。
此设计称为工厂设计模式：
  接口   -->  工厂 -->  各个的子类对象
总结
1、重点阐述了抽象类和接口的使用
2、注意：自己简单总结一下抽象类和接口的不同
3、工厂设计
############################################################
weixin_33711641
关注
JAVA SE基础 面向对象
sweetpymoon的博客
08-11 259
面向对象 面向对象思想概述： 当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。 可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索。 能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。 这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。 面向对象思想特点 1.是一种更符合我们思想习惯的思想 懒人思想 2.可以将复杂的事情简单化 3.将我们从执行者变成了指挥者，角色发生了转换 ...
Java面向对象(高级篇)：一
zjdzka的博客
11-09 1530
1.继承 1.1继承作为面向对象三大特征之一，其重要性不言而喻，在分享我自己对继承的学习之前，我们先引入一段代码 //定义一个Teacher类 class Teacher{ private String name; private int age; public String GetName(){ return name; } public void setName(String name){ this.name=name; } public int Getage(){ return age; } pub
【JavaSE】零基础入门Java语言
C、Java知识分享
03-06 2880
入门java， Java语言是什么、Java语言的发展史、Java语言的特性、Java语言环境、 实现Java程序、Java程序的分析
Java高级类特性（5.25）
安静的美男子
05-25 520
1.创建对象时，代码的执行顺序   [1]初始化父类属性，调用语句块，调用父类的构造   [2]初始化子类属性，调用语句块，调用子类的构造   如果父类构造被重载，需要子类来确定具体调用父类中的哪个构造。 package com; public class Book { protected String name; protected int price; { System
JAVA快速入门-面向对象三大特性-继承性
itdo_just的博客
02-12 326
Tips: 继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫“车”，车有以下属性：车体大...
JAVA编程思想--接口
LLLigj博客
11-03 258
一.抽象类和抽象方法 1.建立这个通用接口的唯一理由是，不同的子类可以用不同的方法表示此接口。2.如果一个类包含一个或多个抽象方法，该类必须被限定为抽象。成为抽象类并不需要所有的方法都是抽象的，仅需将某些方法声明为抽象的即可。interface Instrument1 { int VALUE = 5 ; //在该类中没有任何方法被声明为是public的，但是它们自动就都是public
第三、四章 面向对象 （第三次作业）
qq_74940664的博客
04-01 4029
1下面选项中，类的声明方式正确的是（）正确答案： D2在java中，以下程序的输出结果是（）int x;boolean y;A、运行错误B、0 tureC、0 falseD、0 0正确答案： C3在Java接口中，下列选项中属于有效的方法声明的是（）正确答案： A4下列程序的运行结果是d.show();A、输出lisaB、输出nullC、输出name。
Java语言概述与面向对象思想--中英文翻译.docx
06-10
Java语言是一种由Sun Microsystems公司在1995年推出的高级编程语言，它的出现为Web和互联网计算带来了革命性的变化。Java的特色在于其跨平台性，这意味着编写一次的Java程序可以在任何支持Java的平台上运行，无需...
[零基础学JAVA]Java SE基础部分-01 Java发展及JDK配置.doc
09-30
多线程是Java高级应用的重要部分，允许多个任务同时执行。理解和掌握线程的创建、同步和通信是Java开发者的基本技能。Java API提供了丰富的类集来支持多线程编程，如Thread类和Runnable接口。理解这些类和接口的用法...
JAVA-SE基础知识.pdf
08-18
在实际编程中，还需要学习如何组织类和对象（面向对象编程），理解类、对象、继承、封装和多态的概念，以及异常处理、集合框架、I/O流、文件操作、网络编程和反射等高级主题。随着经验的积累，开发者还将深入学习...
Java SE面向对象部分-06.面向对象基础
11-18
面向对象编程是Java的核心特性，它是相对于面向过程编程的一种编程范式。面向对象的主要思想是将现实世界中的问题抽象为类，然后通过类创建具体的对象来解决。在Java中，面向对象体现在三个主要特征：封装、继承和...
Ace-1-SE-Java-class-libraryl.zip_java class_zip
09-23
Java SE（Standard Edition）是Java平台的一个版本，主要面向桌面应用和服务器端应用开发。 在"王牌1 Java SE 类库查询手册.pdf"中，我们可以预期找到以下关键知识点： 1. **基础类库**：包括核心类库如`java.lang...
抽象类和接口习题
热门推荐
WonderfulBin的博客
04-13 1万+
5.4 精选习题 一、单项选择题 1．（*）下列程序运行的结果是（    ）。 abstract class A {     void f() { System.out.print("good"); } } class B extends A {      public voidf() {          System.out.print("bad");      }  
抽象类与接口
weixin_43573534的博客
03-01 140
定义：是抽象类与全局常量的集合 1.接口的使用优先原则：在抽象类和接口都可以使用的情况下，优先选择接口 2.接口使用interface定义；子类实现接口使用implements关键字 interface A{ public static final String MSG = "some"; void print(); } class B implements A{ pu...
java 抽象类与接口
weixin_30361641的博客
04-07 78
http://www.cnblogs.com/wenruo/p/5366052.html 抽象类 当基类比较抽象的时候一些函数就无法实现。比如动物类，你可以知道猫如何叫狗如何叫，但你无法说清动物如何叫，于是对于比较抽象的基类，其中的一些方法可以只声明，不实现。这样的方法叫做抽象方法，含有抽象方法的类叫做抽象类。抽象方法和抽象类需要用关键字abstract来标识。 含有抽象方法的类的对象是不安...
方法覆写（重点）
编程语言基础知识
03-30 1904
现在已经清楚了继承的基本概念，那么此时就有可能出现这样的一种情况，如果子类限制定义了与父类相同的方法或者是属性的时候，这样的操作就称为覆写。1.方法覆写（重点）所谓的方法的覆写指的是子类定义了与父类方法名称、参数类型及个数完全相同的方法。但是被覆写的方法不能够拥有比父类更为严格的访问控制权限。范例：观察简单的方法覆写class Person{ public void printInfo() { ...
JAVA快速入门-面向对象三大特性-多态性
itdo_just的博客
02-12 327
Tips: 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指...
spring事务详细讲解-深入浅出
最新发布
小电玩
09-08 507
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java SE高级：面向对象实践-抽象类、接口与多态
JavaSE_1_面向对象_4课程深入探讨了面向对象编程的高级概念，特别是抽象类和接口、匿名内部类以及包装类的重要作用。本节内容围绕以下几个关键知识点展开： 1. **面向对象的三个特性**： - 封装：Java通过封装保护...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值