面向对象的特点：
1.面向对象时一种常见的思想，符合人们的思考习惯。
2.面向对象的出现将复杂的问题简单化。
3.面向对象的出现让曾经在过程中的执行者变成对象中的指挥者。
面向对象的三大特征：
--------------------------------------------------------------------------------------------------------------------------------
封装（encapsulation）
封装：是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
好处：（例子：电脑主机）
提高安全性。
提高重用性
将变化隔离
便于使用
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，对外提供访问方法。
private：私有，是一个权限修饰符，用于修饰成员
私有内容只在本类中有效。
注意：私有仅仅是封装的一种体现而已。
Java语言中最小的封装体就是函数。
--------------------------------------------------------------------------------------------------------------------------------
继承（extends）
继承的好处：
1.提高了代码的复用性。
2.让类与类之间产生了关系，给第三个特征多态提供了前提。
java中支持单继承，不直接支持多继承，但对c++中的多继承机制进行了改良。
单继承：一个子类只能有一个直接父类。
多继承：一个子类可以有多个直接父类（java中不允许，进行改良）
在java中是通过“多实现”的方式来提现。
不直接支持多继承，因为多个父类中有相同成员，会产生调用不确定性
java支持多层（多重）继承
C继承B，B继承A
就会出现继承体系。
当要使用一个继承体系时
1.查看该体系中的顶层类，了解该体系的基本功能。
2.创建该体系中的最子类对象，完成功能的使用。
什么时候定义继承呢？
当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种。xxx extends yyy
父类中的功能是不是该类都应该具备，是才能继承。
所属关系： is a 关系
class Person{
String name;
int age;
}
class Student extends Person{
// String name;
// int age;
void study(){
System.out.println(name+"...student study");
}
}
class Worker extends Person{
// String name;
// int age;
void work(){
System.out.println("worker work");
}
}
public class ExtendDemo {
public static void main(String[] args) {
Student s = new Student();
s.name = "zhangsan";
s.age = 15;
s.study();
}
}
子父类中成员变量的特点。
1.成员变量。
2.成员函数。
3.构造函数。
this和super的用法很相似。
this：代表一个本类对象的引用。
super：代表一个父类空间。
1.成员变量。
当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。
子类不能直接访问父类中私有内容。
2.成员函数。
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作，这是函数在子父类中的特性。
函数两个特征：
1.重载。同一个类中。（重载和返回值无关）
2.覆盖。子类中。覆盖也称为重写，覆写。override
子类和父类一模一样，返回值类型相同，参数列表一样，函数名一样。
覆盖注意事项：
1.子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。
父类的方法是私有的（private），不是覆盖。
2.静态只能覆盖静态，或被静态覆盖。
什么时候使用覆盖操作？
当对一个类进行子类的扩展时，子类需要保留父类的功能声明。
但是要定义子类中该功能的特有内容时，就使用覆盖操作完成。
子父类中成员变量的特点。
1.成员变量。
2.成员函数。
3.构造函数。
this和super的用法很相似。
this：代表一个本类对象的引用。
super：代表一个父类空间。
1.成员变量。
当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。
子类不能直接访问父类中私有内容。
2.成员函数。
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作，这是函数在子父类中的特性。
函数两个特征：
1.重载。同一个类中。（重载和返回值无关）
2.覆盖。子类中。覆盖也称为重写，覆写。override
子类和父类一模一样，返回值类型相同，参数列表一样，函数名一样。
覆盖注意事项：
1.子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。
父类的方法是私有的（private），不是覆盖。
2.静态只能覆盖静态，或被静态覆盖。
什么时候使用覆盖操作？
当对一个类进行子类的扩展时，子类需要保留父类的功能声明。
但是要定义子类中该功能的特有内容时，就使用覆盖操作完成。
例：
class Phone{
void call(){}
void show(){
System.out.println(number);
}
}
class NewPhone extends Phone{
void show(){//保留父类原有功能，创建子类特有内容
System.out.println(name);
System.out.println(pic);
super.show();//System.out.println(number);
}
}
3.构造函数。
构造函数没有覆盖。
构造函数没有继承过来，通过super访问父类构造函数。
在子类构造对象时，发现，访问子类构造函数时，父类也运行了，为什么呢？
原因是：在子类的构造函数中第一行有一个默认的隐式语句。super();
子类实例化过程，子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
3.构造函数。
构造函数没有覆盖。
构造函数没有继承过来，通过super访问父类构造函数。
在子类构造对象时，发现，访问子类构造函数时，父类也运行了，为什么呢？
原因是：在子类的构造函数中第一行有一个默认的隐式语句。super();
子类实例化过程，子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
class Fu{
Fu(int x){
System.out.println("fu run"+x);
}
Fu(){
System.out.println("fu run");
}
}
class Zi extends Fu{
Zi(){
//super();// 调用的就是父类中的空参数的构造函数。 this();代表本类的构造函数。
super(4);
System.out.println("zi run");
}
Zi(int x){
super();
System.out.println("zi run "+x);
}
}
public class ExtendDemo2 {
public static void main(String[] args) {
new Zi();
//运行结果： fu run
// zi run
new Zi(6);
//运行结果： fu run
// zi run 6 （子类中所有的构造函数默认都会访问父类中的空参数的构造函数）
}
}
为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中的内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容惊醒初始化的。
所以子类
在构造对象时，必须访问父类中的构造函数。
为了完成这个必须动作，就在子类的构造函数中加入了super()。语句
如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中哪个构造函数。
同时子类构造函数中如果使用this调用了本类构造函数是，super就没有了，因为super和this都只能定义在第一行，所以只能有一个。但是可以保证的是子类中肯定会有其他的构造函数访问父类的构造函数
注意：super语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。
通过super初始化父类内容时，子类的成员变量并未显示初始化，等super()父类初始化完毕后，才进行子类的成员变量显示初始化。
为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中的内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容惊醒初始化的。
所以子类
在构造对象时，必须访问父类中的构造函数。
为了完成这个必须动作，就在子类的构造函数中加入了super()。语句
如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中哪个构造函数。
同时子类构造函数中如果使用this调用了本类构造函数是，super就没有了，因为super和this都只能定义在第一行，所以只能有一个。但是可以保证的是子类中肯定会有其他的构造函数访问父类的构造函数
注意：super语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。
通过super初始化父类内容时，子类的成员变量并未显示初始化，等super()父类初始化完毕后，才进行子类的成员变量显示初始化。
一个对象实例化过程：
Person p = new Person();
1.jvm会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类(如果有直接的父类的情况下)。
2.在堆内存中开辟空间，分配地址。
3.并在对象空间中，对对象中的属性进行默认初始化。
4.调用对应的构造函数进行初始化。
5.在构造函数中，第一行会先调用父类中的构造函数进行初始化。
6.父类初始化完毕后，再对子类的属性进行显示初始化。
7.在进行子类构造函数的特定初始化。
8.初始化完毕后，将地址值赋值给引用变量。
class Fu{
int num = 4;
void show1(){
System.out.println("fu show run");
}
}
class Zi extends Fu{
int num = 5;
void show(){
System.out.println(num+"......"+super.num);
}
void show1(){
System.out.println("zi show run");
}
}
public class ExtendDemo2 {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
z.show1();
//z.show2();
}
}
--------------------------------------------------------------------------------------------------------------------------------
多态：
对象的多态性
class 动物{
}
class 猫 extends 动物{
}
class 狗 extends 动物{
}
猫 x = new 猫();一个对象两种形态。
动物 x = new 猫(); 对象的多态性 父类型引用指向子类对象
猫这类事物即具备着猫的形态，又具备着动物的形态。
简单说：就是一个对象对应着不同类型。
多态在代码中的体现：
父类或者接口的引用，指向其子类对象。
多态的好处：
提高了代码的扩展性，前期定义的代码可以使用后期的功能。
例：
abstract class Animal{
abstract void eat();
}
class Dog extends Animal{
void eat(){
System.out.println("啃骨头");
}
void lookHome(){
System.out.println("看家");
}
}
class Cat extends Animal{
void eat(){
System.out.println("吃鱼");
}
void catchMouse(){
System.out.println("抓老鼠");
}
}
public class DuoTaiDemo {
public static void main(String[] args){
Animal a = new Cat();对象共性，都是动物
method(a);
method(new Dog());
}
public static void method(Animal a){
a.eat();
}
}
多态 类型判断
public static void method(Animal a){
a.eat();
if(a instancesof Cat){instancesof用于判断对象的具体类型，只能应用于引用数据类型判断。
Cat c = (Cat)a;在向下转型之前为进行健壮性的判断。
c.catchMouse();
}
else if(a instancesof Dog){
Dog d = (Dog)a;
d.lookHome();
}
}
多态的弊端:
前期定义的内容不能使用(调用)后期子类的特有内容。
多态的前提:
1.必须要有关系,继承或者实现.
2.要有覆盖.
--------------------------------------------------------
转型：
Animal a = new Cat();自动类型提升，猫直接提升成了动物类型，不能直接访问猫的特有功能。
作用就是限制对特有功能的访问，提高程序扩展性。
专业讲：向上转型。
a.eat();
如果还想用具体动物猫的特有功能，可以将该对象进行向下转型。
Cat c = (Cat)a;向下转型的目的是为了使用子类中的特有方法。
c.eat(); 向上转型是为了限定功能使用，提高程序扩展性。
c.catchMouse();
注意：对于转型，自始至终都是子类对象在做着类型的变化。
Animal a = new Animal();
Cat c = (Cat)a;ClassCastException 类型转换异常。
例子：毕老师和毕姥爷的故事。
class 毕姥爷{
void 讲课(){
System.out.println("管理");
}
void 钓鱼(){
System.out.println("钓鱼");
}
}
class 毕老师 extends 毕姥爷{
void 讲课(){
System.out.println("Java");
}
void 看电影(){
System.out.println("看电影");
}
}
class DuoTaiDemo{
public static void main(String[] args){
毕老师 x = new 毕老师();
x.讲课();
x.看电影（）；
毕姥爷 x = new 毕老师();
x.讲课();
x.钓鱼();
毕老师 y =(毕老师)x;
y.看电影();
}
}
在上下转型的过程在都是子类对象在变化。在父类型和本类型之间转换。
为提高扩展性或者为限制子类的特有功能时向上转型。
当想使用特有功能时向下转型。
多态时，成员的特点。（注意：覆盖只发生在函数上。）
1.成员变量。
编译时：参考引用性变量所属的类中是否有调用的成员变量，有，编译通过，没有，编译失败。
运行时：参考引用性变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。
简单说：编译和运行都参考等号左边。
作为了解。开发中很少见，面试中可能会出现。
2.成员函数。（重点）
编译时：参考引用性变量所属的类中是否有调用的成员变量，有，编译通过，没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。
简单说：编译看左边，运行看右面。
class Fu{
int num = 3;
void show(){
System.out.println("fu show");
}
}
class Zi extends Fu{
int num =4;
System.out.println("zi show");
}
public class DuoTaiDemo {
public static void main(String[] args){
Fu f = new Zi();
System.out.println(f.num);//打印结果3
f.show();// zi show
}
}
3.静态函数。
编译时：参考引用性变量所属的类中是否有调用的静态方法。
运行时：参考引用性变量所属的类中是否有调用的静态方法。
简单说：编译和运行都看左边。
其实对于静态方法是不需要对象的，直接用类名调用即可。
class Fu{
static void show(){
System.out.println("fu static method");
}
}
class Zi extends Fu{
static void show(){
System.out.println("fu static method");
}
}
public class DuoTaiDemo {
public static void main(String[] args){
Fu f = new Zi();
f.method();//fu static method
}
}
1060
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
