黑马程序员_Java基础_面向对象

　　------- android培训、java培训、期待与您交流！ ----------

面向对象的四大特性：

抽象，封装，继承，多态

Java语言对现实生活中的事务进行描述，通过类的新式提现的；

什么描述？

对于事物描述通常只关注两个方面：属性，行为；

对象：其实就是该类事物实实在在的个体。

类与对象之间的关系？

类：事物的描述

对象，该类事物的实例，Java中通过new来创建 

例子：描述小车

分析：

1.属性：轮胎个数，颜色。

2.行为：运行。

定义类其实就是定义类中的成员：

成员：成员变量------->属性

成员函数---->行为

  

面向对象是一种编程方法；

面向对象是一种思维方式；

面向对象不是一种编程语言；

 

成员变量和局部变量的区别：

1.成员变量定义在类中，整个类中都可以访问；

局部变量定义在函数，语句，局部代码块中，只在所属的区域有效

2.成员变量存在于堆内存的对象中。

局部变量存在于栈内存的方法中。

3，成员变量随着对象的创建而存在，随着对象的消失而消失。

局部变量随着所属区域的执行而存在，随着所属区域的结束而释放

4，成员变量都有默认的初始值

局部变量没有默认初始值

 

继承：

在子父类中，成员的特点体现：

成员变量，成员函数，构造函数；

当子父类中的成员变量同名用super区分父类；

This和super的用法很相似：

This:表示本类对象的引用；

Super:代表一个父类空间。

函数两个特性：

1.重载：同一个类中。Overload

1.覆盖：子类中，覆盖也称为重写。Override

覆盖注意事项：

1.子类方法覆盖父类方法时，子类权限必须要大于等于分类的权限。

2.静态只能覆盖静态，或被静态覆盖。

什么时候使用到覆盖操作？

当对一个类进行子类的扩展时，子类需要保留父类的功能声明。

但是要定义子类中该功能特有内容时，就使用覆盖操作完成。

 

抽象类：

抽象：笼统，模糊，看不懂！不具体。

特点：

1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。

抽象方法必须定义在抽象类中。该类必须也被abstract修饰。

2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。

3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。

否则，这个子类还是抽象类。

1.抽象类中有构造函数吗？

有，用于给子类对象进行初始化。

2，抽象类可以不定义抽象方法吗？

可以的。但是很少见，目的就是不让该类创建对象。

AWT的适配器对象就是这种类。

通常这个类中的方法有方法体，但是却没有内容。

abstract class Demo

{

void show1()

{}

void show2()

{}

}

3，抽象关键字不可以和那些关键字共存?

private 不行

static不行

final不行

4，抽象类和一般类的异同点。

相同点：

抽象类和一般类都是用来描述事物的，都在内部定了成员。

不同：

1，一般类有足够的信息描述事物。

抽象类描述事物的信息有可能不足。

2，一般类中不能定义抽象方法，只能定非抽象方法。

抽象类中可定义抽象方法，同时也可以定义非抽象方法。

3，一般类可以被实例化。

抽象类不可以被实例化。

5，抽象类一定是个父类吗？

是的。因为需要子类覆盖其方法后才可以对子类实例化。

 

 接口（interface）：

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口interface。

定义接口使用的关键字不是class，是interface.

对于接口当中常见的成员：而且这些成员都有固定的修饰符。

1，全局常量: public  static final 

2，抽象方法。public abstract 

由此得出结论，接口中的成员都是公共的权限

接口不可以实例化。

只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。

否则，这个子类就是一个抽象类。

在java中不直接支持多继承，因为会出现调用的不确定性。

所以java将多继承机制进行改良，在java中变成了多实现。

一个类可以实现多个接口。

抽象类和接口的异同点：

相同点：

都是不断向上抽取而来的。

不同点：

1，抽象类需要被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。

接口中只能定义抽象方法，必须由子类去实现。

3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。

接口的实现是like a 关系，在定义体系额外功能。

一个对象实例化过程：

Person p = new Person();

1，JVM会读取指定的路径下的Person.class文件，并加载进内存，

并会先加载Person的父类(如果有直接的父类的情况下).

2，在堆内存中的开辟空间，分配地址。

3，并在对象空间中，对对象中的属性进行默认初始化。

4，调用对应的构造函数进行初始化。

5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。

6，父类初始化完毕后，在对子类的属性进行显示初始化。

7，在进行子类构造函数的特定初始化。

8，初始化完毕后，将地址值赋值给引用变量.

 

多态：

对象的多态性。

class 动物

{}

class 猫extends 动物

{}

class 狗extends 动物

{}

猫x = new 猫();

动物x = new 猫();//一个对象，两种形态。

猫这类事物即具备者猫的形态，又具备着动物的形态。

这就是对象的多态性。

简单说：就是一个对象对应着不同类型. 

多态在代码中的体现：

父类或者接口的引用指向其子类的对象。

多态的好处：

提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：

前期定义的内容不能使用(调用)后期子类的特有内容。

多态的前提：

1，必须有关系，继承，实现。

2，要有覆盖。

Animal a = newCat(); 

自动类型提升，猫对象提升了动物类型。但是特有功能无法访问。

作用就是限制对特有功能的访问。

专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。

如果还想用具体动物猫的特有功能。

你可以将该对象进行向下转型。

Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。

instanceof：用于判断对象的具体类型。只能用于引用数据类型判断

通常在向下转型前用于健壮性的判断。
 

封装:

隐藏对象的内部实现细节，把对象的属性和操作结合为一个独立的整体

 

什么是封装？

封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据

其实，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

 

封装的好处：

提高了程序中的可复用性和可维护性，降低了操作过程中保持数据内容的负担。

可以把对象私有数据和公共数据分开，保护私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性；

例子：

class User {
    private String name ;//姓名属性
    private int age; //年龄   ，私有保证对象不能直接使用属性
    //获取对象的属性值方法
    public String getName() {
        return name;
    }
    //设置对象属性值方法
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}