Java面向对象编程

类与方法

概述

Java 语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用 Java 语言去设计、开发计算机程序。 这里的 对象 泛指现实中一切事物，每种事物都具备自己的 属性 和 行为 。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去 操作实现。

以 洗衣服举例子 :

面向过程：把衣服脱下来 --> 找一个盆 --> 放点洗衣粉 --> 加点水 --> 浸泡 10 分钟 --> 揉一揉 --> 清洗衣服 --> 拧干 --> 晾 起来

面向对象：把衣服脱下来 --> 打开全自动洗衣机 --> 扔衣服 --> 按钮 --> 晾起来

特点

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。

面向对象的语言中，包含了三大基本特征，即 封装、继承和多态 。

---

类 ：是一组相关 属性 和 行为 的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该

类事物。

现实中，描述一类事物：

属性 ：就是该事物的状态信息。

行为 ：就是该事物能够做什么。

例子:

类：狗

属性：名字、体重、年龄、颜色

行为：走、跑、叫

创建对象：

类名 对象名 = new 类名 ();

使用对象访问类中的成员 :

对象名 . 成员变量；

对象名 . 成员方法 () ；

继承与多态

super和this的区别

super ：代表父类的 存储空间标识 ( 可以理解为父亲的引用 ) 。

this ：代表 当前对象的引用 ( 谁调用就代表谁 ) 。

super和this的用法

class Animal {
    public void eat() {
        System.out.println( "animal : eat" );
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println( "cat : eat" );
    }

    public void eatTest() {
        this.eat(); // this 调用本类的方法
        super.eat(); // super 调用父类的方法
    }
}

public class ExtendsDemo08 {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Cat c = new Cat();
        c.eatTest();
    }
}

注意：

子类的每个构造方法中均有默认的 super() ，调用父类的空参构造。手动调用父类构造会覆盖默认的 super() 。

super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

 继承的特点

1. Java只支持单继承，不支持多继承。

//一个类只能有一个父类，不可以有多个父类。
class C extends A{} //正确
class C extends A，B... //错误写法

2. Java 支持多层继承 ( 继承体系 ) 。

class A{} 
class B extends A{} 
class C extends B{}

3. 子类和父类是一种相对的概念。

---

多态

多态 ：是指同一行为，具有多个不同表现形式

定义：多态是继封装、继承之后，面向对象的第三大特性。

生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也 是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

格式：父类类型 变量名 = new 子类对象；

           变量名 . 方法名 ();

Fu f = new Zi(); 
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

例：

//父类
public abstract class Animal {
    public abstract void eat();
}

//子类
class Cat extends Animal {
    public void eat() {
        System.out.println( "吃鱼" );
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println( "吃骨头" );
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Animal a1 = new Cat();
        // 调用的是 Cat 的 eat 
        a1.eat();
        // 多态形式，创建对象
        Animal a2 = new Dog();
        // 调用的是 Dog 的 eat
        a2.eat();
    }
}

---

 

多态的转型

分为向上转型与向下转型两种：

向上转型 ：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

父类类型 变量名 = new 子类类型 ();

如： Animal a = new Cat ();

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。 一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

 子类类型 变量名 = (子类类型) 父类变量名;

如 : Cat c = ( Cat ) a ;

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

//定义类
abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println( "吃鱼" );
    }

    public void catchMouse() {
        System.out.println( "抓老鼠" );
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println( "吃骨头" );
    }

    public void watchHouse() {
        System.out.println( "看家" );
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();// 调用的是 Cat 的 eat
        // 向下转型 
        Cat c = (Cat) a;
        c.catchMouse(); // 调用的是 Cat 的 catchMouse 
    }
}