黑马程序员【Java中的面向对象】

标签：

                                                         Java中的面向对象

     在软件开发的学习中， 我最先接触的开发语言就是java，但都是简单的函数和循环数组的应用。说道面向对象，第一次看到这个词的时候还是在C#的学习过程中，我记得当时PPT上霸气的解释，什么是对象？万物皆对象！够霸气吧，当时的面向对象思想对我来说还是挺崩溃的，什么继承多态啊！经过了无数的联系项目的书写，终于对面向对象有了一定的理解，现在刚好在java的学习中再度重温面向对象，那么就将我眼中的面向对象写出来分享给大家。

     说到面向对象，我们就不得不提一下他的三大特性，继承封装和多态。我们先从封装说起，什么是封装呢？就是把对象的属性和操作联合为一个整体，并且隐藏内部实现细节。这个说法比较官方，简单的说就是把属性用private修饰，然后建立公有方法给属性赋值，并且在方法中控制给属性赋值的规则。在上代码之前给大家分享一个MyEclipse封装的快捷方式，写好了私有属性后按alt+shift+s出现菜单栏后再按r就可以全部封装了。

public class Student {
    private String stuname;
    private int stuage;
    private int stuscore;// 光标定位在这里按快捷键
    public Student(String name,int age,int score){
        this.stuname = name;
        this.stuage = age;
        this.stuscore = score;
    }
    public String getStuname() {
        return stuname;
    }

    public void setStuname(String stuname) {
        this.stuname = stuname;
    }

    public int getStuage() {
        return stuage;
    }

    public void setStuage(int stuage) {
        this.stuage = stuage;
    }

    public int getStuscore() {
        return stuscore;
    }

    public void setStuscore(int stuscore) {
        this.stuscore = stuscore;
    }
    
    public void say(){
        System.out.println(this.stuname+"正在和大家打招呼");
    }
}

     上面就是对一个对象的封装，可以在set方法里添加赋值需求。借着上面封装好的类，我们来看下一个特性，也就是继承。继承在我们日常生活中的理解就是从我们的上一辈或者上司老师那里获取到他的东西，而且一般是全部的东西，那么继承在java中是什么意思呢？继承就是从已有的类中派生出新的类，新的类能够吸收已有类的数据和行为，并能扩展新的能力。一般将这个已有类称为父类或是基类，而新的类称为子类或派生类。在java继承特性中，只能实现单继承，也就是所有子类只能有一个父类，子类继承父类的关键字是extends后面跟上类名。

     下面是一个张三类，他继承了Student类，并且覆盖了类中的say方法：

public class StuZS extends Student {

    public StuZS(String name, int age, int score) {
        super(name, age, score);
    }
    public void say(){
        System.out.println("大家好！");
    }


}

     在这里有几点需要注意的地方，在父类中的私有属性或方法在子类中是不能被继承的，也就是说这时候StuZS类不能直接使用stuname变量，需要使用类中的set(赋值)get(取值)方法。如果在父类中有一个带参的构造函数并且没有无参的构造函数，那么子类在继承父类之后，必须有相同构造函数并且函数中的第一条语句要调用父类中的构造函数，因为当你实例化出子类对象的时候，会先走到父类的构造函数中执行再回到子类的构造函数中。所以如果我们的父类中有一个带参构造，那么基于后面的代码的友好书写，再加一个无参的构造函数。

     现在我们知道了子类可以使用父类的方法，那么现在问题来了，如果子类中有和父类重名的属性或方法，那该怎么办呢？正子类中有和父类的重名方法我们叫做覆盖，也就是说重写了父类的方法，在调用的时候可以把两个类的方法看成一种，但是其实是不一样，在子类中通过this和super关键字可以区分出来，this调用的是本类的方法，super调用的是父类方法，属性也是一样，代码如下：

public class StuZS extends Student {

    public StuZS(String name, int age, int score) {
        super(name, age, score);
    
    }
    public void say(){
        System.out.println("大家好！");
    }
   public void thisAndSuper(){
       this.say();
       super.say();
   }

}

    public static void main(String[] args) {
        StuZS stu = new StuZS("张三", 20, 100);
        stu.thisAndSuper();
    }

     这段代码会输出“张三正在和大家打招呼”和“大家好！”两句话，所以说我们在子类中可以区分出这个方法或属性到底属于谁。但是我们想想这样做有什么意义呢，我们继承的目的就是要子类可以使用父类的属性或方法，让他们“不分彼此”，而父类我们一般只是将方法与属性创建出来，所以父类say()方法中的内容时多余的，用不到的，那么就出现了我们的抽象方法。java中的抽象方法用abstract关键字修饰。在给大家看具体代码前先看一下抽象方法的几个特性和注意事项：

1、抽象方法所在的类必然是抽象类，抽象类同样用abstract修饰

2、抽象类中可以有普通方法和属性

3、抽象方法不能有方法体

4、子类必须重写父类的抽象方法，除非子类本身也是一个抽象类

5、抽象类不能被实例化

     好了抽象类和抽象方法的一些基本注意事项我们也了解了，那么下面的事情就简单了，我们只需要稍稍的修改一下代码就OK了：

public class StuZS extends Student {

    public StuZS(String name, int age, int score) {
        super(name, age, score);
    
    }
    @Override
    public void say() {
        // TODO Auto-generated method stub
        
    }
        public void thisAndSuper(){
        this.say();
        super.say();
    }
}

     这样我们再用super调用父类方法的时候会发现报出了红线，是不可以被调用的。

     下面就是我们今天的重头戏，也就是多态，前面的封装和继承几乎都是在为多态做着准备，那么什么是多态呢？还是先来一段官方的解释：多态性是指允许不同类的对象对同一消息作出响应，多态包括参数化和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名的问题。多态既然这么牛，那么多态都有什么好处呢？下面我们来一一列举：

1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。
2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。
3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。
4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。
5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要

     看到了多态的这么多好处，是不是觉得很厉害的样子，就让我们来看看多态在代码中的呈现方式(一段神绕的代码，大家自行观看，夜深了)：

public class StuA {
    public void say(StuD stu){
        System.out.println("D say Hello");
    }
    public void say(StuA stu){
        System.out.println("A say Hello");
    }

}

public class StuB extends StuA {
    public void say(StuA stu){
        System.out.println("A say Hello");
    }
    public void say(StuD stu){
        System.out.println("B say Hello");
    }

}

public class StuD extends StuA {
    public void say(StuA stu){
        System.out.println("A say Hello");
    }
    public void say(StuB stu){
        System.out.println("B say Hello");
    }

}

public static void main(String[] args) {
        StuA a = new StuA();
        StuB b = new StuB();
        StuD d = new StuD();
        a.say(b);
        a.say(d);
        b.say(a);
        b.say(b);
        d.say(d);
        d.say(d);
        
    }

      在这我也帮不了大家什么，绕出来多态你就理解的差不多了，运行结果给大家，我要睡觉去了。

A say Hello
D say Hello
A say Hello
A say Hello
D say Hello
D say Hello

黑马程序员【Java中的面向对象】

标签：

原文地址：http://www.cnblogs.com/fanfu1/p/4518587.html