什么是java面向对象象
点击联系发帖人
时间：2018-07-10 13:21
【java初学者】理解，从面向过程 到 面向对象，面向接口，面向切面
本文章适合初学者，主要是整理清楚，java ,从面向过程 到 面向对象，面向接口，面向切面。
假如我们正在建立一栋别墅。
过程：搅拌水泥，拉砖头，请工人，粉刷墙壁等等，一系列非常 琐碎的事情，
对象：砌墙！
接口：这里，建立一个厕所，这里建立一个客厅！
切面：就这么理解吧，假如你和女友约会，
周五：女友出门之前需要 洗澡，洗头，化妆，（吃饭），卸妆，洗澡，睡觉
周六：女友出门之前需要 洗澡，洗头，化妆，（喝饮料），卸妆，洗澡，睡觉
周日：女友出门之前需要 洗澡，洗头，化妆，（去游乐园），卸妆，洗澡，睡觉
你能接触的，就是很女友 吃喝玩乐，
下面开始上代码：
一、第一个包，面向过程，非常简单
aop001 Test.java
package aop001;
* 面向过程的写法，一次性把所有代码写到一起去
public class Test {
public static void main(String[] args) {
System.out.println(&第一个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周6&+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第二个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周6&+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第一个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周日&+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第二个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周日&+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
二、aop002 增加了 2个类 Girl1.java，面向对象！
Girl1.java
package aop002;
public class Girl1 {
public void KFC(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第一个女孩&);
System.out.println(datetime+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第一个女孩&);
System.out.println(datetime+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
Girl2.java :和1一样的事情，只是一个约会，一个去肯德基
package aop002;
public class Girl2 {
public void KFC(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第二个女孩&);
System.out.println(datetime+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第二个女孩&);
System.out.println(datetime+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
package aop002;
* 面向对象，OOP，抽象成2个女孩的类，以及她的属性
public class Test {
public static void main(String[] args) {
Girl1 g1 = new Girl1();
Girl2 g2 = new Girl2();
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
三、aop003 增加了Girl ,面向接口
2个女孩的没有变动
package aop003;
public interface Girl {
public void KFC(String datetime);
public void meet(String datetime);
Test.java 已经发生了改变！new 对象由 Girl1 g1=new Girl1() ; 表位Girl g1=new Girl1();
变化 虽然只是由Girl1 改为Girl ，但是更加清楚！
package aop003;
* 面向接口
* 本例的缺点：
* 1.非业务逻辑的代码，跟核心的业务逻辑代码，耦合一起
* 2.一旦非业务逻辑的代码发生改变，全部实现类都要去改
public class Test {
public static void main(String[] args) {
Girl g1 = new Girl1();
Girl g2 = new Girl2();
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
四、aop004 面向切面，增加了GirlProxy.java 可以理解是代理！经纪人！它负责准备大量的事情，而你只需要写对象。
比如 经纪人，安排了的早餐，汽车出行，会议，拍广告；你只需要带入对象即可。
这里，Girl ,Girl1,Girl2 都没有改变，
GirlProxy.java
package aop004;
* 1、经纪人和要明星，必须实现同一个接口
* 2、把明星作为一个本类的一个属性，用于调用
public class GirlProxy implements Girl {
public GirlProxy(String name){
if (&girl1&.equals(name)){
g = new Girl1();
}else if (&girl2&.equals(name)){
g = new Girl2();
public void KFC(String datetime) {
g.KFC(datetime);
public void meet(String datetime) {
g.meet(datetime);
package aop004;
* 增加一个代理类，类似与明星的经纪人
* 把核心的业务逻辑的代码 和 非核心的 分离
* 把非核心的代码交给经纪人(proxy)去管理,
* 注意：经纪人和要明星，必须实现同一个接口
public class Test {
public static void main(String[] args) {
Girl g1 = new GirlProxy(&girl1&);
Girl g2 = new GirlProxy(&girl2&);
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
输出正常：
五、aop005 这个也是面向切面，但是做的事情更少，是4的效率版
Girl 没有变，Girl1,2得到了简化。
Girl1.java
package aop005;
public class Girl1 implements Girl{
public void KFC(String datetime){
System.out.println(&[核心业务逻辑]我是第一个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&吃肯德基&);
public void meet(String datetime){
System.out.println(&[核心业务逻辑]我是第一个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&约会&);
Girl2.java :和1差不多。
package aop005;
public class Girl2 implements Girl {
public void KFC(String datetime){
System.out.println(&[核心业务逻辑]我是第二个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&吃肯德基&);
public void meet(String datetime){
System.out.println(&[核心业务逻辑]我是第二个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&约会&);
GirlProxy.java
package aop005;
* 1、经纪人和要明星，必须实现同一个接口
* 2、把明星作为一个本类的一个属性，用于调用
public class GirlProxy implements Girl {
public GirlProxy(String name){
if (&girl1&.equals(name)){
g = new Girl1();
}else if (&girl2&.equals(name)){
g = new Girl2();
public void KFC(String datetime) {
System.out.println(&洗澡&);
System.out.println(&化妆&);
System.out.println(&穿衣服&);
System.out.println(&*****************&);
g.KFC(datetime);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime) {
System.out.println(&洗澡&);
System.out.println(&化妆&);
System.out.println(&穿衣服&);
System.out.println(&*****************&);
g.meet(datetime);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
package aop005;
* 增加一个代理类，类似与明星的经纪人
* 把核心的业务逻辑的代码 和 非核心的 分离
* 把非核心的代码交给经纪人(proxy)去管理,
* 注意：经纪人和要明星，必须实现同一个接口
public class Test {
public static void main(String[] args) {
Girl g1 = new GirlProxy(&girl1&);
Girl g2 = new GirlProxy(&girl2&);
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
代码正常运行：
这5个例子，虽然简单，但是 重要的是理解！
看完一定要自己写一个不同的，才能算领会。
本文章适合初学者，主要是整理清楚，java ,从面向过程 到 面向对象，面向接口，面向切面。
假如我们正在建立一栋别墅。
过程：搅拌水泥，拉砖头，请工人，粉刷墙壁等等，一系列非常 琐碎的事情，
对象：砌墙！
接口：这里，建立一个厕所，这里建立一个客厅！
切面：就这么理解吧，假如你和女友约会，
周五：女友出门之前需要 洗澡，洗头，化妆，（吃饭），卸妆，洗澡，睡觉
周六：女友出门之前需要 洗澡，洗头，化妆，（喝饮料），卸妆，洗澡，睡觉
周日：女友出门之前需要 洗澡，洗头，化妆，（去游乐园），卸妆，洗澡，睡觉
你能接触的，就是很女友 吃喝玩乐，
下面开始上代码：
一、第一个包，面向过程，非常简单
aop001 Test.java
package aop001;
* 面向过程的写法，一次性把所有代码写到一起去
public class Test {
public static void main(String[] args) {
System.out.println(&第一个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周6&+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第二个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周6&+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第一个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周日&+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第二个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周日&+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
二、aop002 增加了 2个类 Girl1.java，面向对象！
Girl1.java
package aop002;
public class Girl1 {
public void KFC(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第一个女孩&);
System.out.println(datetime+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第一个女孩&);
System.out.println(datetime+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
Girl2.java :和1一样的事情，只是一个约会，一个去肯德基
package aop002;
public class Girl2 {
public void KFC(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第二个女孩&);
System.out.println(datetime+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第二个女孩&);
System.out.println(datetime+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
package aop002;
* 面向对象，OOP，抽象成2个女孩的类，以及她的属性
public class Test {
public static void main(String[] args) {
Girl1 g1 = new Girl1();
Girl2 g2 = new Girl2();
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
三、aop003 增加了Girl ,面向接口
2个女孩的没有变动
package aop003;
public interface Girl {
public void KFC(String datetime);
public void meet(String datetime);
Test.java 已经发生了改变！new 对象由 Girl1 g1=new Girl1() ; 表位Girl g1=new Girl1();
变化 虽然只是由Girl1 改为Girl ，但是更加清楚！
package aop003;
* 面向接口
* 本例的缺点：
* 1.非业务逻辑的代码，跟核心的业务逻辑代码，耦合一起
* 2.一旦非业务逻辑的代码发生改变，全部实现类都要去改
public class Test {
public static void main(String[] args) {
Girl g1 = new Girl1();
Girl g2 = new Girl2();
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
四、aop004 面向切面，增加了GirlProxy.java 可以理解是代理！经纪人！它负责准备大量的事情，而你只需要写对象。
比如 经纪人，安排了的早餐，汽车出行，会议，拍广告；你只需要带入对象即可。
这里，Girl ,Girl1,Girl2 都没有改变，
GirlProxy.java
package aop004;
* 1、经纪人和要明星，必须实现同一个接口
* 2、把明星作为一个本类的一个属性，用于调用
public class GirlProxy implements Girl {
public GirlProxy(String name){
if (&girl1&.equals(name)){
g = new Girl1();
}else if (&girl2&.equals(name)){
g = new Girl2();
public void KFC(String datetime) {
g.KFC(datetime);
public void meet(String datetime) {
g.meet(datetime);
package aop004;
* 增加一个代理类，类似与明星的经纪人
* 把核心的业务逻辑的代码 和 非核心的 分离
* 把非核心的代码交给经纪人(proxy)去管理,
* 注意：经纪人和要明星，必须实现同一个接口
public class Test {
public static void main(String[] args) {
Girl g1 = new GirlProxy(&girl1&);
Girl g2 = new GirlProxy(&girl2&);
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
输出正常：
五、aop005 这个也是面向切面，但是做的事情更少，是4的效率版
Girl 没有变，Girl1,2得到了简化。
Girl1.java
package aop005;
public class Girl1 implements Girl{
public void KFC(String datetime){
System.out.println(&[核心业务逻辑]我是第一个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&吃肯德基&);
public void meet(String datetime){
System.out.println(&[核心业务逻辑]我是第一个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&约会&);
Girl2.java :和1差不多。
package aop005;
public class Girl2 implements Girl {
public void KFC(String datetime){
System.out.println(&[核心业务逻辑]我是第二个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&吃肯德基&);
public void meet(String datetime){
System.out.println(&[核心业务逻辑]我是第二个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&约会&);
GirlProxy.java
package aop005;
* 1、经纪人和要明星，必须实现同一个接口
* 2、把明星作为一个本类的一个属性，用于调用
public class GirlProxy implements Girl {
public GirlProxy(String name){
if (&girl1&.equals(name)){
g = new Girl1();
}else if (&girl2&.equals(name)){
g = new Girl2();
public void KFC(String datetime) {
System.out.println(&洗澡&);
System.out.println(&化妆&);
System.out.println(&穿衣服&);
System.out.println(&*****************&);
g.KFC(datetime);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime) {
System.out.println(&洗澡&);
System.out.println(&化妆&);
System.out.println(&穿衣服&);
System.out.println(&*****************&);
g.meet(datetime);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
package aop005;
* 增加一个代理类，类似与明星的经纪人
* 把核心的业务逻辑的代码 和 非核心的 分离
* 把非核心的代码交给经纪人(proxy)去管理,
* 注意：经纪人和要明星，必须实现同一个接口
public class Test {
public static void main(String[] args) {
Girl g1 = new GirlProxy(&girl1&);
Girl g2 = new GirlProxy(&girl2&);
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
代码正常运行：
这5个例子，虽然简单，但是 重要的是理解！
看完一定要自己写一个不同的，才能算领会。扫一扫体验手机阅读
Java面向对象的基本思想理解
<span type="1" blog_id="1955941" userid='
24篇文章，1W+人气，0粉丝
大数据时代的微服务之路
￥51.00435人订阅
<span type="1" blog_id="1955941" userid='Java面向对象编程（封装/继承/多态）实例解析
转载 &更新时间：日 09:52:22 & 作者：书思BookReflect
这篇文章主要介绍了Java面向对象编程（封装/继承/多态）实例解析的相关内容，具有一定参考价值，需要的朋友可以了解下。
本文主要介绍了面向对象的三大特征实例解析，下面看看具体内容。
封装一个Teacher和Student类
package com.hz.
public class Teacher {
private String majorD
private String teachC
private int teachA
public Teacher() {
public Teacher(String name,String majorDirection,String teachCourse,int teachAge) {
this.name =
this.majorDirection = majorD
this.teachCourse = teachC
this.teachAge = teachA
public String getName() {
public void setName(String name) {
this.name =
public String getMajorDirection() {
return majorD
public void setMajorDirection(String majorDirection) {
this.majorDirection = majorD
public String getTeachCourse() {
return teachC
public void setTeachCourse(String teachCourse) {
this.teachCourse = teachC
public int getTeachAge() {
return teachA
public void setTeachAge(int teachAge) {
this.teachAge = teachA
public String toString() {
return "姓名=" + getName() + ", 专业方向=" + getMajorDirection()
+ ", 所教课程=" + getTeachCourse() + ", 教龄=" + getTeachAge();
package com.hz.
import java.util.A
* @author ztw
public class Student {
private String[]
public Student() {
public Student(String name,int age,String[] courses,String interest) {
this.name =
this.age =
this.courses =
this.interest =
public void setName(String name){
this.name =
public String getName(){
public void setAge(int age){
if(age&0){
System.out.println("年龄不能为负值");
this.age =
public int getAge(){
public void setCourses(String[] courses){
this.courses =
public String getCourses(){
return Arrays.toString(courses);
public void setInterest(String interest){
this.interest =
public String getInterest(){
public String toString() {
return "姓名=" + getName() + ", 年龄=" + getAge() + ", 课程=" + getCourses()
+ ", 兴趣=" + getInterest();
package com.hz.
public class Test {
public static void main(String[] args) {
String arr[] = {"阿斯达","是的","大概","太诱惑"};
Student stu = new Student("张三",21,arr,"打球");
Teacher tea = new Teacher("王五","阿斯达","阿斯达",99);
System.out.println(stu);
System.out.println(tea);
输出结果：
姓名=张三, 年龄=21, 课程=[阿斯达, 是的, 大概, 太诱惑], 兴趣=打球
姓名=王五, 专业方向=阿斯达, 所教课程=阿斯达, 教龄=99
定义Play，TaoistPriest，Master，Warrior
public class Play {
public Play(String main) {
this.main =
public void hitMonster() {
System.out.println(main+"打怪");
* TaoistPriest:道士
* @author ztw
public class TaoistPriest extends Play {
System.out.print("我是道士：");
public TaoistPriest(String main) {
super(main);
* Master:法师
* @author ztw
public class Master extends Play{
System.out.print("我是法师：");
public Master(String main) {
super(main);
* Warrior:武士
* @author ztw
public class Warrior extends Play{
System.out.print("我是武士：");
public Warrior(String main) {
super(main);
public class Test {
public static void main(String[] args) {
TaoistPriest tp = new TaoistPriest("灵魂火符");
tp.hitMonster();
Master m = new Master("雷电术");
m.hitMonster();
Warrior w = new Warrior("烈火术");
w.hitMonster();
输出结果：
我是道士：灵魂火符打怪
我是法师：雷电术打怪
我是武士：烈火术打怪
服务器，客户端交互
LoginListener
public interface LoginListener {
public void succeed(String msg);
public void failed(String msg);
MyLoginListener
public class MyLoginListener implements LoginListener{
public void succeed(String msg) {
System.out.println(msg);
public void failed(String msg) {
System.out.println(msg);
public class Server {
public void login(String userName,String password,LoginListener listener) {
System.out.print("loading");
for (int i = 0; i & 10; i++) {
Thread.sleep(100*i);
System.out.print(".");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
if(userName.equals("zhangsan") && password.equals("123")){
if(listener!=null){
listener.succeed("登录成功");
if(listener!=null){
listener.succeed("登录失败");
public class LoginTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String userName = sc.next();
System.out.println("请输入用户密码：");
String password = sc.next();
Server server = new Server();
server.login(userName, password, new MyLoginListener());
请输入用户名：
请输入用户密码：
loading……….登录成功
以上就是本文关于Java面向对象编程（封装，继承，多态）实例解析的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站：、等，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具}
本文章适合初学者，主要是整理清楚，java ,从面向过程 到 面向对象，面向接口，面向切面。
假如我们正在建立一栋别墅。
过程：搅拌水泥，拉砖头，请工人，粉刷墙壁等等，一系列非常 琐碎的事情，
对象：砌墙！
接口：这里，建立一个厕所，这里建立一个客厅！
切面：就这么理解吧，假如你和女友约会，
周五：女友出门之前需要 洗澡，洗头，化妆，（吃饭），卸妆，洗澡，睡觉
周六：女友出门之前需要 洗澡，洗头，化妆，（喝饮料），卸妆，洗澡，睡觉
周日：女友出门之前需要 洗澡，洗头，化妆，（去游乐园），卸妆，洗澡，睡觉
你能接触的，就是很女友 吃喝玩乐，
下面开始上代码：
一、第一个包，面向过程，非常简单
aop001 Test.java
package aop001;
* 面向过程的写法，一次性把所有代码写到一起去
public class Test {
public static void main(String[] args) {
System.out.println(&第一个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周6&+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第二个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周6&+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第一个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周日&+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第二个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周日&+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
二、aop002 增加了 2个类 Girl1.java，面向对象！
Girl1.java
package aop002;
public class Girl1 {
public void KFC(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第一个女孩&);
System.out.println(datetime+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第一个女孩&);
System.out.println(datetime+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
Girl2.java :和1一样的事情，只是一个约会，一个去肯德基
package aop002;
public class Girl2 {
public void KFC(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第二个女孩&);
System.out.println(datetime+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第二个女孩&);
System.out.println(datetime+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
package aop002;
* 面向对象，OOP，抽象成2个女孩的类，以及她的属性
public class Test {
public static void main(String[] args) {
Girl1 g1 = new Girl1();
Girl2 g2 = new Girl2();
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
三、aop003 增加了Girl ,面向接口
2个女孩的没有变动
package aop003;
public interface Girl {
public void KFC(String datetime);
public void meet(String datetime);
Test.java 已经发生了改变！new 对象由 Girl1 g1=new Girl1() ; 表位Girl g1=new Girl1();
变化 虽然只是由Girl1 改为Girl ，但是更加清楚！
package aop003;
* 面向接口
* 本例的缺点：
* 1.非业务逻辑的代码，跟核心的业务逻辑代码，耦合一起
* 2.一旦非业务逻辑的代码发生改变，全部实现类都要去改
public class Test {
public static void main(String[] args) {
Girl g1 = new Girl1();
Girl g2 = new Girl2();
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
四、aop004 面向切面，增加了GirlProxy.java 可以理解是代理！经纪人！它负责准备大量的事情，而你只需要写对象。
比如 经纪人，安排了的早餐，汽车出行，会议，拍广告；你只需要带入对象即可。
这里，Girl ,Girl1,Girl2 都没有改变，
GirlProxy.java
package aop004;
* 1、经纪人和要明星，必须实现同一个接口
* 2、把明星作为一个本类的一个属性，用于调用
public class GirlProxy implements Girl {
public GirlProxy(String name){
if (&girl1&.equals(name)){
g = new Girl1();
}else if (&girl2&.equals(name)){
g = new Girl2();
public void KFC(String datetime) {
g.KFC(datetime);
public void meet(String datetime) {
g.meet(datetime);
package aop004;
* 增加一个代理类，类似与明星的经纪人
* 把核心的业务逻辑的代码 和 非核心的 分离
* 把非核心的代码交给经纪人(proxy)去管理,
* 注意：经纪人和要明星，必须实现同一个接口
public class Test {
public static void main(String[] args) {
Girl g1 = new GirlProxy(&girl1&);
Girl g2 = new GirlProxy(&girl2&);
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
输出正常：
五、aop005 这个也是面向切面，但是做的事情更少，是4的效率版
Girl 没有变，Girl1,2得到了简化。
Girl1.java
package aop005;
public class Girl1 implements Girl{
public void KFC(String datetime){
System.out.println(&[核心业务逻辑]我是第一个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&吃肯德基&);
public void meet(String datetime){
System.out.println(&[核心业务逻辑]我是第一个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&约会&);
Girl2.java :和1差不多。
package aop005;
public class Girl2 implements Girl {
public void KFC(String datetime){
System.out.println(&[核心业务逻辑]我是第二个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&吃肯德基&);
public void meet(String datetime){
System.out.println(&[核心业务逻辑]我是第二个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&约会&);
GirlProxy.java
package aop005;
* 1、经纪人和要明星，必须实现同一个接口
* 2、把明星作为一个本类的一个属性，用于调用
public class GirlProxy implements Girl {
public GirlProxy(String name){
if (&girl1&.equals(name)){
g = new Girl1();
}else if (&girl2&.equals(name)){
g = new Girl2();
public void KFC(String datetime) {
System.out.println(&洗澡&);
System.out.println(&化妆&);
System.out.println(&穿衣服&);
System.out.println(&*****************&);
g.KFC(datetime);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime) {
System.out.println(&洗澡&);
System.out.println(&化妆&);
System.out.println(&穿衣服&);
System.out.println(&*****************&);
g.meet(datetime);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
package aop005;
* 增加一个代理类，类似与明星的经纪人
* 把核心的业务逻辑的代码 和 非核心的 分离
* 把非核心的代码交给经纪人(proxy)去管理,
* 注意：经纪人和要明星，必须实现同一个接口
public class Test {
public static void main(String[] args) {
Girl g1 = new GirlProxy(&girl1&);
Girl g2 = new GirlProxy(&girl2&);
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
代码正常运行：
这5个例子，虽然简单，但是 重要的是理解！
看完一定要自己写一个不同的，才能算领会。
本文章适合初学者，主要是整理清楚，java ,从面向过程 到 面向对象，面向接口，面向切面。
假如我们正在建立一栋别墅。
过程：搅拌水泥，拉砖头，请工人，粉刷墙壁等等，一系列非常 琐碎的事情，
对象：砌墙！
接口：这里，建立一个厕所，这里建立一个客厅！
切面：就这么理解吧，假如你和女友约会，
周五：女友出门之前需要 洗澡，洗头，化妆，（吃饭），卸妆，洗澡，睡觉
周六：女友出门之前需要 洗澡，洗头，化妆，（喝饮料），卸妆，洗澡，睡觉
周日：女友出门之前需要 洗澡，洗头，化妆，（去游乐园），卸妆，洗澡，睡觉
你能接触的，就是很女友 吃喝玩乐，
下面开始上代码：
一、第一个包，面向过程，非常简单
aop001 Test.java
package aop001;
* 面向过程的写法，一次性把所有代码写到一起去
public class Test {
public static void main(String[] args) {
System.out.println(&第一个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周6&+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第二个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周6&+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第一个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周日&+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
System.out.println(&第二个女孩子洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&周日&+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
二、aop002 增加了 2个类 Girl1.java，面向对象！
Girl1.java
package aop002;
public class Girl1 {
public void KFC(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第一个女孩&);
System.out.println(datetime+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第一个女孩&);
System.out.println(datetime+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
Girl2.java :和1一样的事情，只是一个约会，一个去肯德基
package aop002;
public class Girl2 {
public void KFC(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第二个女孩&);
System.out.println(datetime+&吃肯德基&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime){
System.out.println(&洗澡&);
System.out.println(&穿衣服&);
System.out.println(&化妆&);
System.out.println(&*****************&);
System.out.println(&我是第二个女孩&);
System.out.println(datetime+&约会&);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
package aop002;
* 面向对象，OOP，抽象成2个女孩的类，以及她的属性
public class Test {
public static void main(String[] args) {
Girl1 g1 = new Girl1();
Girl2 g2 = new Girl2();
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
三、aop003 增加了Girl ,面向接口
2个女孩的没有变动
package aop003;
public interface Girl {
public void KFC(String datetime);
public void meet(String datetime);
Test.java 已经发生了改变！new 对象由 Girl1 g1=new Girl1() ; 表位Girl g1=new Girl1();
变化 虽然只是由Girl1 改为Girl ，但是更加清楚！
package aop003;
* 面向接口
* 本例的缺点：
* 1.非业务逻辑的代码，跟核心的业务逻辑代码，耦合一起
* 2.一旦非业务逻辑的代码发生改变，全部实现类都要去改
public class Test {
public static void main(String[] args) {
Girl g1 = new Girl1();
Girl g2 = new Girl2();
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
四、aop004 面向切面，增加了GirlProxy.java 可以理解是代理！经纪人！它负责准备大量的事情，而你只需要写对象。
比如 经纪人，安排了的早餐，汽车出行，会议，拍广告；你只需要带入对象即可。
这里，Girl ,Girl1,Girl2 都没有改变，
GirlProxy.java
package aop004;
* 1、经纪人和要明星，必须实现同一个接口
* 2、把明星作为一个本类的一个属性，用于调用
public class GirlProxy implements Girl {
public GirlProxy(String name){
if (&girl1&.equals(name)){
g = new Girl1();
}else if (&girl2&.equals(name)){
g = new Girl2();
public void KFC(String datetime) {
g.KFC(datetime);
public void meet(String datetime) {
g.meet(datetime);
package aop004;
* 增加一个代理类，类似与明星的经纪人
* 把核心的业务逻辑的代码 和 非核心的 分离
* 把非核心的代码交给经纪人(proxy)去管理,
* 注意：经纪人和要明星，必须实现同一个接口
public class Test {
public static void main(String[] args) {
Girl g1 = new GirlProxy(&girl1&);
Girl g2 = new GirlProxy(&girl2&);
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
输出正常：
五、aop005 这个也是面向切面，但是做的事情更少，是4的效率版
Girl 没有变，Girl1,2得到了简化。
Girl1.java
package aop005;
public class Girl1 implements Girl{
public void KFC(String datetime){
System.out.println(&[核心业务逻辑]我是第一个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&吃肯德基&);
public void meet(String datetime){
System.out.println(&[核心业务逻辑]我是第一个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&约会&);
Girl2.java :和1差不多。
package aop005;
public class Girl2 implements Girl {
public void KFC(String datetime){
System.out.println(&[核心业务逻辑]我是第二个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&吃肯德基&);
public void meet(String datetime){
System.out.println(&[核心业务逻辑]我是第二个女孩&);
System.out.println(&[核心业务逻辑]&+datetime+&约会&);
GirlProxy.java
package aop005;
* 1、经纪人和要明星，必须实现同一个接口
* 2、把明星作为一个本类的一个属性，用于调用
public class GirlProxy implements Girl {
public GirlProxy(String name){
if (&girl1&.equals(name)){
g = new Girl1();
}else if (&girl2&.equals(name)){
g = new Girl2();
public void KFC(String datetime) {
System.out.println(&洗澡&);
System.out.println(&化妆&);
System.out.println(&穿衣服&);
System.out.println(&*****************&);
g.KFC(datetime);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
public void meet(String datetime) {
System.out.println(&洗澡&);
System.out.println(&化妆&);
System.out.println(&穿衣服&);
System.out.println(&*****************&);
g.meet(datetime);
System.out.println(&*****************&);
System.out.println(&卸妆&);
System.out.println(&洗澡&);
System.out.println(&睡觉&);
package aop005;
* 增加一个代理类，类似与明星的经纪人
* 把核心的业务逻辑的代码 和 非核心的 分离
* 把非核心的代码交给经纪人(proxy)去管理,
* 注意：经纪人和要明星，必须实现同一个接口
public class Test {
public static void main(String[] args) {
Girl g1 = new GirlProxy(&girl1&);
Girl g2 = new GirlProxy(&girl2&);
g1.KFC(&周六&);
g1.meet(&周日&);
g2.KFC(&周六&);
g2.meet(&周日&);
代码正常运行：
这5个例子，虽然简单，但是 重要的是理解！
看完一定要自己写一个不同的，才能算领会。扫一扫体验手机阅读
Java面向对象的基本思想理解
<span type="1" blog_id="1955941" userid='
24篇文章，1W+人气，0粉丝
大数据时代的微服务之路
￥51.00435人订阅
<span type="1" blog_id="1955941" userid='Java面向对象编程（封装/继承/多态）实例解析
转载 &更新时间：日 09:52:22 & 作者：书思BookReflect
这篇文章主要介绍了Java面向对象编程（封装/继承/多态）实例解析的相关内容，具有一定参考价值，需要的朋友可以了解下。
本文主要介绍了面向对象的三大特征实例解析，下面看看具体内容。
封装一个Teacher和Student类
package com.hz.
public class Teacher {
private String majorD
private String teachC
private int teachA
public Teacher() {
public Teacher(String name,String majorDirection,String teachCourse,int teachAge) {
this.name =
this.majorDirection = majorD
this.teachCourse = teachC
this.teachAge = teachA
public String getName() {
public void setName(String name) {
this.name =
public String getMajorDirection() {
return majorD
public void setMajorDirection(String majorDirection) {
this.majorDirection = majorD
public String getTeachCourse() {
return teachC
public void setTeachCourse(String teachCourse) {
this.teachCourse = teachC
public int getTeachAge() {
return teachA
public void setTeachAge(int teachAge) {
this.teachAge = teachA
public String toString() {
return "姓名=" + getName() + ", 专业方向=" + getMajorDirection()
+ ", 所教课程=" + getTeachCourse() + ", 教龄=" + getTeachAge();
package com.hz.
import java.util.A
* @author ztw
public class Student {
private String[]
public Student() {
public Student(String name,int age,String[] courses,String interest) {
this.name =
this.age =
this.courses =
this.interest =
public void setName(String name){
this.name =
public String getName(){
public void setAge(int age){
if(age&0){
System.out.println("年龄不能为负值");
this.age =
public int getAge(){
public void setCourses(String[] courses){
this.courses =
public String getCourses(){
return Arrays.toString(courses);
public void setInterest(String interest){
this.interest =
public String getInterest(){
public String toString() {
return "姓名=" + getName() + ", 年龄=" + getAge() + ", 课程=" + getCourses()
+ ", 兴趣=" + getInterest();
package com.hz.
public class Test {
public static void main(String[] args) {
String arr[] = {"阿斯达","是的","大概","太诱惑"};
Student stu = new Student("张三",21,arr,"打球");
Teacher tea = new Teacher("王五","阿斯达","阿斯达",99);
System.out.println(stu);
System.out.println(tea);
输出结果：
姓名=张三, 年龄=21, 课程=[阿斯达, 是的, 大概, 太诱惑], 兴趣=打球
姓名=王五, 专业方向=阿斯达, 所教课程=阿斯达, 教龄=99
定义Play，TaoistPriest，Master，Warrior
public class Play {
public Play(String main) {
this.main =
public void hitMonster() {
System.out.println(main+"打怪");
* TaoistPriest:道士
* @author ztw
public class TaoistPriest extends Play {
System.out.print("我是道士：");
public TaoistPriest(String main) {
super(main);
* Master:法师
* @author ztw
public class Master extends Play{
System.out.print("我是法师：");
public Master(String main) {
super(main);
* Warrior:武士
* @author ztw
public class Warrior extends Play{
System.out.print("我是武士：");
public Warrior(String main) {
super(main);
public class Test {
public static void main(String[] args) {
TaoistPriest tp = new TaoistPriest("灵魂火符");
tp.hitMonster();
Master m = new Master("雷电术");
m.hitMonster();
Warrior w = new Warrior("烈火术");
w.hitMonster();
输出结果：
我是道士：灵魂火符打怪
我是法师：雷电术打怪
我是武士：烈火术打怪
服务器，客户端交互
LoginListener
public interface LoginListener {
public void succeed(String msg);
public void failed(String msg);
MyLoginListener
public class MyLoginListener implements LoginListener{
public void succeed(String msg) {
System.out.println(msg);
public void failed(String msg) {
System.out.println(msg);
public class Server {
public void login(String userName,String password,LoginListener listener) {
System.out.print("loading");
for (int i = 0; i & 10; i++) {
Thread.sleep(100*i);
System.out.print(".");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
if(userName.equals("zhangsan") && password.equals("123")){
if(listener!=null){
listener.succeed("登录成功");
if(listener!=null){
listener.succeed("登录失败");
public class LoginTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String userName = sc.next();
System.out.println("请输入用户密码：");
String password = sc.next();
Server server = new Server();
server.login(userName, password, new MyLoginListener());
请输入用户名：
请输入用户密码：
loading……….登录成功
以上就是本文关于Java面向对象编程（封装，继承，多态）实例解析的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站：、等，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具}
我要回帖
更多关于 java面向对象经典题目 的文章
更多推荐
- ·坐在学霸的棍棍上如何背单词词对吗？
- ·当代大学生如何担当民族复兴重任该如何加强民族认同感？
- ·菠萝啤可以代替啤酒做菜吗不可以和鸡精一起做菜吃？
- ·今年高一了还能长高吗，发育正常吗？
- ·如何养鸽子子对家里风水有影响吗？
- ·现在哪种流量卡比较好什么卡，流量比较多，用着每月不算太贵的啊？最近好像又新出一个抖音卡，我大王卡用时间太长了
- ·如何删除百度网盘里备份的通话记录手机端的备份应用可以备份应用的数据吗
- ·雅洁密码锁说明书智能锁这个品牌好吗？
- ·三星s8后壳什么材质各个版本后壳不一样吗
- ·八年级下册英语unit6上英语书unit1toplc5sectionb
- ·想在日本语雪茄怎么说买蛋白粉 不知道日语怎么说 谁知道
- ·白本护照加拿大拒签率带DT被拒签怎么办
- ·东南证券公司配资配资怎么开户？
- ·黑驹令你马力十足如何注册商标过商标吗？还有哪些分类可以如何注册商标？
- ·东南证券从业人员配资配资公司怎么样？
- ·第5题B和C网约车与滴滴有何区别？
- ·cross和be angry at 和 with同义还是和angrily同义？
- ·东南和讯期货鑫东财配资配资到底好不好？
- ·什么是java面向对象象
- ·我想在东湖南期货配资做配资靠谱吗？
- ·请问一下有没有清楚安徽新华电脑安徽万通汽车专修学院院的。这个学校是民办的，靠谱吗。这个真的对于我来说很重要。。。
- ·想到别人上大学都有怎样认识班里的同学的同学一起，然而自己一个人孤零零的，倍感蓝瘦，该怎办😂
- ·东南国内原油期货配资代理不会坑人吧？
- ·东南期货配资是什么怎么样？
- ·根据区里规划 试时启动美丽乡村建设规划方案计划是啥意思 试时啥意思
- ·东南国内原油期货配资代理好像挺多人在做？
- ·这最难读的几个字字怎么读，在线等，急
- ·东南国内正规期货配资平台是正规的公司么？
- ·刚工作不适应工作环境的句子新环境，，怎么办
- ·形容相依相伴的成语。是什么动物
- ·东南淄博期货配资资信誉如何？
- ·请问这神是四个字是什么意思字，是什么字体？
- ·东南期货配资哪里好口碑好吗？
- ·宁夏建投集团人员名单公司是国企吗
