黑马程序员_java面向对象

面向对象：三个特征：封装，继承，多态。

以后开发：其实就是找对象使用。没有对象，就创建一个对象。

找对象，建立对象，使用对象。维护对象的关系。

抽象类的特点：
1，抽象方法一定在抽象类中。
2，抽象方法和抽象类都必须被abstract关键字修饰。
3，抽象类不可以用new创建对象。因为调用抽象方法没意义。
4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类和一般类没有太大的不同。
该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。
通过抽象方法来表示。
抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例化。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

用对象思考：继承

1，子类的构造方法，没有指定调用父类的构造方法，则统统自动调用父类无参的构造方法。

2，在子类的构造方法中，指定了父类的带参的构造方法的调用，就不会调用父类无参的构造方法。

用对象思考：多态

1，包含抽象方法的类，必须是抽象类。

2，多态指：不同对象收到相同的消息时，会产生不同行为。具体指两个或多个属于不同类的对象，对于同一个消息（方法调用）作出不同响应的方式，也可以说是同一个类在不同场合表现出不同的行为特征。

3，抽象方法没有方法体，包含抽象方法的类，一定是抽象类，抽象类不能被实例化，也就是不能被new实例对象，必被继承，抽象方法必被重写(override)，抽象类同时也不能是密封或静态的(sealead,static)。

4，虚方法（Virtural）是有方法体的，如果子类不重写方法，默认调用虚方法，如果重写则调用重写后的方法。

5，简单工厂模式:是一种创建型的设计模式，用于在调用者不知道对象属于哪个子类的情况下，创建不同的对象。

用对象思考：接口

1，接口是一种规范和标准，一个类如果实现了一个接口，意味着这个类遵循了某种规范和约定。

2，接口中不能包含字段，可以包含属性和方法，索引器。

3，接口作为参数：传递了实现接口的类的对象。接口作为返回值：返回一个实现接口类的对象。

4，如果某个类实现了一个接口，必须重写实现这个接口的方法。

接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract 

记住：接口中的成员都是public的。

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

关于继承：

java只支持单继承，不支持多继承。
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承。也就是一个继承体系
 
如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
简单一句话：查阅父类功能，创建子类对象使用功能。
 
子父类中的函数：
当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。
这种情况是函数的另一个特性：重写(覆盖)
当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。
 
子父类的覆盖：
1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
2，静态只能覆盖静态。
3，子父类中的构造函数。
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
 
为什么子类一定要访问父类中的构造函数。
因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定定义在子类构造函数的第一行。
 
结论：
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
重载：
在同一个类中，相同的方法名，不同的参数类型，个数，顺序构成重载，当只有返值不同时，不能构成重载。
记住大家：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。

final : 最终。作为一个修饰符，
1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3，被final修饰的方法不可以被复写。
4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。
而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。
单词间通过_连接。
5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
静态类：
用static修饰，只包含静态成员，不可以包含实例成员，使用类名调用静态成员，不能被实例化，不能包含实例构造函数。
非静态类：
不用static修饰，可以包含静态成员，可以包含实例成员，使用实例对象调用非静态成员，可以被实例化，包含实例构造函数。
static特点：
1，随着类的加载而加载。也就说：静态会随着类的消失而消失。说明它的生命周期最长。
2，优先于的对象存在明确一点：静态是先存在。对象是后存在的。
3，被所有对象所共享
4，可以直接被类名所调用。
实例变量和类变量的区别：
1，存放位置：
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2，生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
1，静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。
2，静态方法中不可以定义this，super关键字。因为静态优先于对象存在。所以静态方法中不可以出现this。
3，主函数是静态的。
静态有利有弊
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用
弊端：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)
什么时候使用静态？
要从两方面下手：
因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量(类变量)呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
 
什么时候定义静态函数呢？
当功能内部没有访问到非静态数据(对象的特有数据)，
那么该功能可以定义成静态的。
当多个类中出现相同功能，但是功能主体不同，
这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。
总结：
(1).抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前
目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时
不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
(2).继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表
述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。
新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新
类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可
以修改或增加新的方法使之更适合特殊的需要。
(3).封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象
计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，
这些对象通过一个受保护的接口访问其他对象。
(4). 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和
包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的
解决了应用程序函数同名问题。