黑马程序员_05. 面向对像的三大特征(详解)

五、黑马程序员_面向对像的三大特征(详解)

-------- android培训、java培训、期待与你交流
--------

A.封装 ； B.继承 ； C.多态

A.封装
(1):封装概述
现实生活中的封装是指将某些东西放在一个容器当中打包起来。比如主机箱中封装了主板、电源、光驱等就变成了主机。在java当中，封装通常是把某些代码封装在一个方法当中，形成一个独立的小功能，可以方便对外
界调用，它隐藏对象的属性和实现细节。
(2):封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
(3):封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
(4):private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问
d:由于权限是私有的，外界访问不到，对外视为封装，它也是封装的一种表现形式。
(5):private最常见的应用：
a:把成员变量用private修饰
b:提供对应的getXxx()和setXxx()方法
(6):this关键字的概述和应用
a:为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题，于是我们用this来标识成员变量，区分了局部变量与成员变量。
b:this关键字特点
它代表当前类的对象引用，可以看作一个对象。谁调用这个方法,那么该方法的内部的this就代表谁。
(7).static关键字的特点
a:随着类的加载而加载
b:优先于对象存在
c:被类的所有对象共享
举例：假如所有的中国人都用一个国籍，那么country可以定义为一个共享属性，没必要在每个对像中都建一分。
d:可以通过类名调用,其实它本身也可以通过对象名调用。推荐使用类名调用。静态修饰的内容一般我们称其为：与类相关的，类成员
e:static的注意事项
(1):在静态方法中是没有this关键字的
静态是随着类的加载而加载，this是随着对象的创建而存在。静态比对象先存在。
(2):静态方法只能访问静态的成员变量和静态的成员方法。也就是说，静态只能访问静态,非静态可以访问静态的也可以访问非静态的。
(8).静态变量和成员变量的区别
a:所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
b:内存中位置不同
静态变量存储于方法区的静态区(共享区)
成员变量存储于堆内存
c:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
d:调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
(9).main方法的格式详细解释
格式：public static void main(String[] args) {}
public 被jvm调用，访问权限足够大。
static 被jvm调用，不用创建对象，直接类名访问
void   被jvm调用，不需要给jvm返回值
main  一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args 以前用于接收键盘录入的
(10).构造方法
它是用来给对象中的成员进行初始化的，是描述某类事物一存在就应该具备的某些特性。它有如下几个特点：
a:方法名与类名相同；
b:没有返回值类型，连void都没有；
c:没有具体的返回值；
d:它和方法一样，也可以重载。
需要注意：
a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法；
b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法。
c:当一个方法名与构造函数同名时(也就是在构造方法名前加了返回值类型)，不视为构造方法，而是当一个普通方法。
(11):代码块
使用{}括起来的代码被称为代码块，根据其位置和声明的不同分为：
a.构造代码块  b.静态码块  c.局部代码块  d.同步代码块(涉及到多线程，这里不讲)。
a.构造代码块: 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。它是用来给对像统一初始化的；
b.静态码块：在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
c.局部代码块：在方法中出现；限定变量生命周期，及早释放，提高内存利用率。
代码块示例：
class Demo{
{
System.out.println("我是构造代码块，是用于给所有对像进行统一初始化的。");
}
static{
System.out.println("我是静态代码块，是用于给类进行初始化的，我只执行一次。");
}

public static void show(){
{
System.out.println("我是局部代码块，是用于限定变量生命周期，及早释放，提高内存利用率。");
}
System.out.println("----show----");
}
}
(12):当我们创建了一个对像时，到底做了哪些事情呢程?
比如：Student s = new Student();
它会进行这样一个过程：
(1):加载Student.class文件进内存；
(2):静态代码块先执行，如果有的话；
(3):在栈内存为s开辟空间；
(4):在堆内存为学生对象开辟空间，并分配地址值；
(5):对学生对象的成员变量进行默认初始化；
(6):对学生对象的成员变量进行显示初始化；
(7):对对像的构造代码块进行初始化；
(8):对应的构造函数初始化；
(9):把堆内存中的地址赋值给s变量。
(13):文档说明书
当我们写好一个程序交给别人用的时候，我们只需要给出编绎后的字节码文件，但是只给字节码文件别人是不知道如何去使用的，这时我们需要带一个说明书给使用者看，而这个说明书就是文档说明书。我们可能通过javadoc命令来生成文档制作。一些相关参数：
@author 指定作者
@version    指定版本
@param      指定参数
@return     指定返回值
javadoc工具解析对应的java源文件
格式: javadoc -d 目录 -author -version 源文件名称.java
目录: 就是指定说明文档要生成的对应的文件夹

B.继承
(1).概述：在现实生活中所谓的继承就是指儿子得到了老子传下来的东西。而在java当中的继承(使用extends关键字)是指如果一个类继承了另一个类，那么这个类就相当于得到了这个类中所有的非私有成员。可以简化书写。
(2).继承的好处
a:提高了代码的复用性;
b:提高了代码的维护性;
c:让类与类之间产生了关系，是多态的前提;
d:是一个体系建立的基础。
(3).继承的弊端
增强了类的耦合性,让类与类间的关系更加的紧密。
在开发的时候，我们的原则是：高内聚(就是自己完成某件事情的能力),低耦合(类与类的关系).
(4).继承特点
a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹).不过有些语言是支持多继承，格式：extends 类1,类2,...
b:Java支持多层继承(继承体系)
c:在一个体系中，如果我们想使用一个体系，我们最好参阅底层(父类功能)，使用顶层(创建子类对像).
(5).使用继承要注意：
a:子类只能继承父类所有非私有的成员(成员方法和成员变量)；
b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法；
c:不要为了部分功能而去继承，类与类要有关系才可以，必须是is a 的关系。
(6).this和super的区别和应用
a.this用来区分成员变量和局部变量重名，super用来区分子父类成员变量重名；
b.this(...)
调用本类的构造方法, super(...) 调用父类的构造方法;
c.this.成员方法 调用本类的成员方法,也可以调用父类的方法,super.成员方法 调用父类的成员方法.
(7).继承后子类构造方法的特点
a.子类中所有的构造方法默认都会访问父类中空参数的构造方法super().因为子类在初始化的时候必须先要参考父类是如何初始化的，可能子类会使用到父类中的数据;
b.如果父类中定义了有参数的构造方法，那么空参数的构造方法就没有了，我们必须在子类中手动调用父类有参改数的构造方法，否则编绎不通过;
c.需要注意的是，super(…)或者this(….)必须出现在构造方法的第一条语句上;
(8).继承后子类对成员的调用的变化
a.如果出现同名的变量，如果不加this，默认是子类的变量，如果想调用父类的，要使用super.变量名 来调用；
b.如果出现同名的方法时，子类会覆盖掉父类的方法，也叫做方法的生写。
(9).那么什么是重写呢？
就是当子父类中出现了一模一样的方法时，这时子类的方法会把父类的方法覆盖掉，这个过程就叫做生写。
重写的好处是：当父类中的定义的内容不是我们想要的，这时候我们可以沿袭父类中的功能定义，定义子类的特有内容。这样做有利于程序的扩展。
但是重写需要注意：
a.父类中私有方法不能被重写,因为父类私有方法子类根本就无法继承;
b.子类重写父类方法时，访问权限不能更低, 最好就一致;
c.父类静态方法，子类也必须通过静态方法进行重写(其实这个算不上方法重写,但是现象确实如此).简单的说，就是静态只能覆盖静态;
d.重写生重载不一样，重写是要一模一样，重载只看参数列表(与返回值无关)。这也是 Override和Overload的区别。
(10).final关键字
a.final修饰特点
(1).修饰类，类不能被继承;
(2).修饰变量，变量就变成了常量，只能被赋值一次;
(3).修饰方法，方法不能被重写；
(4).对于引用类型，被final修饰其地址值不能被改变,但对象中的属性可以改变。
b.对final修饰的初始化值的两种方式
(1).在定义被final修饰的变量时直接给值；
(2).先声明一个被final修饰的变量，在对像初始化时再赋值。

C.多态
所谓多态，是指一个事物存在的多种表现形态。比如，人继承动物的话，那么人也可以称为动物。
a.多态的前题：
1. 要有继承关系；
2. 子类要覆盖父类的方法；
3. 子类对像要指向父类的引用（专业术语叫做向上转型）。
b. 多态成员变量的特点：
编绎和运行都看左边（也就是父类），包括请态。
c. 多态中的成员方法：
编绎看父类（左边），运行看子类（右边）。
d. 多态中静态方法：
编绎和运行都参考你类，不存在重写。
e.多态的好处与弊端：
好处: 大大的提高了程序的扩展性，可以用来接收所有的子类类型。
弊端: 但是只能是父类的引用调用父类的方法，不能使用子类的特有属性和功能。
注意：如果子父类中存在一样的方法，但是子类或父类中的方法没有static修饰，那么就不存覆盖，编绎会失败。
f.向下转型：
将父类引用强转成子类类型，可以让子类可以使用更多的功能（包括父类的，也包括子类特有的）叫做向下转型。
但前题是这个父类的引用必须先指向子类的对像才可以转。
综上所述：其实多态至始至终都是子类在做着变化。
g.多态的应用示例：
class Animal{
public void eat(){
System.out.println("animal eat");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("Cat eat");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat");
}
}
public AnimalTest{
public void main(String[] args){
// 传入哪个对像，执行的就是对应对像的方法。
method(new Dog());
method(new Cat());
}
//可以接收Animal及子类对像，包括后期出现的子类对像。
public static void method(Animal animal){
animal.eat();
}
}