黑马程序员——面向对象

---------------Android培训、java培训、期待与您交流---------------

面向对象：
面向对象是基于面向过程的，是一种编程思想。

所谓，万物皆对象，每个对象都有自己的属相和方法。面向对象是将功能封装进对象

面向过程：强调的是功能行为

面向对象：将功能封装进对象，强调具备功能的对象

面向对象将：执行者转换成指挥者

面向对象的三大特征：封装、继承、多态

面向对象举例： 买电脑（执行者转换成指挥者）
假如一个人去买电脑，他对电脑一窍不通，那么他可以找一位懂电脑的朋友，带着朋友去电子城购买电脑
他不需要懂电脑的任何东西，只要告诉朋友，我需要什么价位的电脑，做什么用，那么朋友就可以帮助他购买，
在这其中，他扮演的就是指挥者，他的朋友就是执行者，从他要买电脑（执行者）转换为他邀请他朋友帮助他购买（指挥者）

类和对象的关系：
类：对现实生活中事物的描述
对象：就是这类事物实实在在存在的个体
属性：对应类中的 成员变量
行为：对应类中的 成员函数

例如：
类：描述一个汽车的属性：颜色、轮胎数，方法：跑



对象：创建一个汽车对象，实实在在存在的个体



局部变量：定义在方法、语句、或代码块中，没有初始化值（需要初始化），作用域整个大括号，在栈内存中存储，声明周期较短
成员变量：定义在类中，方法体外，有初始化值（有默认值，创建对象时初始化值），作用域整个类，在堆内存中存储，声明周期较长

static：修饰符，用于修饰成员（成员变量和成员函数）。

当被静态修饰后，就多了一种调用方式，即：类名.静态

静态的使用：工具类（Tool），定义一个类，类中是静态的公共方法（在不需要操作类中特有属性的前提下，可以通过类名直接调用，因为不创建对象，无法访问类中特有的属性）

特点：

1、随着类的加载而加载，随着类的消失而消失，也就是生命周期最长。

2、优先于对象存在。静态先存在，对象后存在

3、被所有对象所共享

4、可以直接被类名调用

5、静态方法只能访问静态成员（方法和变量）【非静态方法可以访问静态方法】

6、静态方法中不可以定义this，super关键字

因为静态优先于对象存在，this存在于对象中，没对象，不可以访问

成员变量（实例变量）：随着对象的建立而建立，存在与堆内存中，

静态成员变量（类变量）：随着类的加载而加载，存在于方法区中，生命周期最长

匿名对象：即：没有名字的对象
new Car（）.run（）：
匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成
如果对一个对象进行多个成员调用使用，必须给这个对象起个名字
匿名对象使用方式二：可以直接将匿名对象作为实际参数进行传递
匿名对象类的代码使用案例

/*
匿名对象：
是没有名字的对象。

应用场景：
A:当对对象方法仅进行一次调用的时
B:匿名对象可以作为实际参数进行传递
*/
class Student
{
public void show()
{
System.out.println("student -- show");
}
}

class Test
{
//引用类型作为形式参数
public void print(Student s)
{
s.show();
}
public void print(int a)
{
System.out.println(a);
}
}

class NiMingTest 
{
public static void main(String[] args) 
{
//如何使用show()方法呢?
Student s = new Student();
s.show();
//匿名对象的使用
new Student().show();

Test t = new Test();
//Student s2 = new Student();
//t.print(s2);
t.print(new Student());
}
}

代码块执行顺序：

1，静态代码块：用于给类进行初始化。随着类的加载而执行，且只执行一次，优先于主函数执行（只要用到类（构造函数），类就会加载，静态代码块就会执行）

2，构造代码块：用于给所有对象初始化，对象一建立就运行，并优先于构造函数运行

（构造代码块中是所有对象共性的内容）

3，构造函数：与类名同名，用于给对象初始化（当类中定义了构造函数后，默认的构造函数就没有了。不用定义返回值类型，不用写return语句）

面向对象有三大特征：封装、继承和多态

封装是继承的前提，继承是多态的前提

一、封装：隐藏对象的属性和实现细节，仅对外提供公共的访问方式
封装原则：将不需要对外提供的内容隐藏起来，提供公共方法对其访问
例如：由于不懂电脑，找人去买电脑，我不需要知道他是怎么跟卖电脑的进行砍价，进行交谈的
我只要知道他把电脑给我买上就行
封装的好处：便于使用，提高重用性和安全性
private ：权限修饰符，用于修饰类中的成员（成员变量、成员函数）
class Person
{
一个变量通常有两种访问方式：1、获取（get） 2、设置（set）
private int age：将age私有化以后，除了Person类外，其他类无法访问
public void setAge(int age) 为了能是其他类可以访问age，定义一个函数，用来改变age的值
{
this.age=age;
}
}
注意：私有（private）仅仅是封装的一种表现形式

this关键字使用：

this：用于区分成员变量和局部变量。
this：那个对象在调用this所在的函数，this就代表那个对象
this语句：用在构造函数之间进行互相调用，且this语句必须放在第一行，因为要给对象进行初始化



二、继承：让类与类之间产生关系，提高了代码的复用性，是多态的一种前提
1、Java只支持单继承，不支持多继承，但java保留了这种机制，并用另一种体现形式来完成表示：多实现
因为多继承容易带来安全隐患，当多个父类中定义了相同功能，但功能内容不同时，子类对象不确定要执行那个一个

class SubDemo extends Demo{} //ok

class SubDemo extends Demo1,Demo2...//error

2、Java支持多层继承：A继承B，C继承A

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

子父类中变量的特点：
子类中出现非私有的同名变量时，子类要访问本类变量：this.变量名
子类要访问父类变量：super.变量名
代码体现：

class Fu //定义父类
{
int num = 4;
public void setNum(int num)
{
this.num =num;
}
public int getNum()
{
return this.num;
}
}
//子类继承父类
class Zi extends Fu<span style="white-space:pre">	</span>
{
int num = super.num;//访问父类中的成员变量
void show()
{
System.out.println("num="num);
}
}

class  ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();//创建子类对象
z.show();
}
}

执行结果



子父类中函数的特点：
子类中出现和父类一模一样的函数时，父类中的函数会被子类的函数所覆盖
子类覆盖父类，必须保证子类权限大于父类权限
函数的重载：函数名相同，参数列表不同
函数的重写：函数名和参数列表都相同
代码体现：

class Fu //创建父类
{
void show()//父类中的show方法
{
System.out.println("fu show");
}
}
//子类继承父类
class Zi extends Fu
{
//子类复写父类中的show方法
void show()
{
System.out.println("zi show");
}
}

class  ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}

执行结果：



子父类中构造函数的特点：
子类的构造函数第一行有一条隐士的语句：super（）用来调用父类中的空参的构造函数
因为父类中的数据，子类可以直接获取，所以，子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类创建对象时要先访问父类中的构造函数
如果要访问父类中指定的构造函数，可以通过super语句来指定
如果要访问父类中没有空参的构造函数，必须指定super要访问父类中哪一个
子类至少要访问一个父类中的构造函数
代码体现：

class Fu //创建父类
{
int num;//父类中的成员变量
Fu()//父类构造方法
{
num = 60;//在对象初始化时，给变量赋值
System.out.println("fu run,,"+num);
}
Fu(int x) //父类带参的构造方法
{
this();//this语句，访问父类中空参的构造方法
System.out.println("fu.."+x);
}
}
class Zi extends Fu<span style="white-space:pre">	</span>//子类继承父类
{
Zi()<span style="white-space:pre">	</span>//子类空参的构造函数
{
super(4);//方法父类中带参的构造方法
System.out.println("zi run");
}
Zi(int x)<span style="white-space:pre">	</span>//子类带参的构造函数
{
this();//访问子类中空参的构造函数
System.out.println("zi....."+x);
}
}
class  ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi(10);//创建子类对象，并传递参数
System.out.println(z.num);
}
}

执行结果：



子父类中代码块的执行顺序：
父类的静态代码块 --- 子类的静态代码块 --- 父类的构造代码块 --- 父类的构造函数 --- 子类的构造代码块 --- 子类的构造函数

final关键字：这是一个修饰符，可以修饰类、方法、变量
1、被final修饰的类是一个最终类，不可以被继承
2、被final修饰的方法是一个最终方法，不可以被覆盖
3、被final修饰的变量是一个常量，只能赋值一次
final既可以修饰成员变量，又可以修饰局部变量
内部类定义在类中的局部变量位置上时，只能访问被final是修饰的局部变量

三、多态：事物存在的多种体现形态
多态的表现：父类引用指向子类对象
父类的引用也可以接收自己的子类对象
多态的前提：必须是类与类之间有关系，要么继承，要么实现
通常还有一个前提，存在：覆盖
多态的好处：提高了程序的扩展性
多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类中的成员

转型：



注意：
我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态自始至终都是子类对象在做变化

多态中成员的特点：
成员函数：编译看左边（父类），运行看右边
编译过程中，如果父类有此函数，编译通过，但是运行时，子类可能将此函数覆盖了，所以运行时看右边（子类）
成员变量：无论编译、运行都看左边
静态：无论编译、运行都看左边（父类）

Object 类：是所有对象的直接或者间接“父类"object类中定义的是所有对象都具备的功能

equals()方法：比较两个对象是否相等
finalize()方法：垃圾回收机制（GC）来调用
toString()方法：

抽象类：在多个类中，出现功能相同，但功能主体不同，可以进行向上抽取，这时，之抽取功能定义，而不抽取功能主体
例如：多个类中都拥有学习方法，但学习的内容不同，这是可以向上进行抽取，将学习方法进行抽取



抽象类的特点：
1、抽象方法只能定义在抽象类中
2、抽象类和抽象方法都必须被abstract关键字修饰
3、抽象方法只定义方法声明，并不定义方法的实现
4、抽象类不可以被创建对象（不可以被new）
5、只有子类继承抽象类，并覆盖抽象类中的所有抽象方法，抽象类才可以被实例化，否则该子类还是一个抽象类
6、抽象类只能单继承
7、抽象关键字abstract不能和：final，static，private 共存
抽象类实例：
模板设计方法：在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这是就将不确定的部分暴露出去，由该类的子类去完成，确定的部分定义成final，不让起去复写
模板设计例子：



接口：Interface
接口的特点：
1、接口中的成员都是固定的：public
成员变量：public static final 是一个常量
成员函数：public abstract 是一个抽象方法
2、接口的出现将“多继承”通过另一种形式体现出来，即：“多实现”。
一个类在继承一个类的同时还能去实现接口

接口中的成员都是固定的：public

成员变量：publicstatic final 是一个常量

成员函数：publicabstract 是一个抽象方法

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。一个类在继承一个类的同时还能去实现接口

类与接口的体现：

类与接口之间是实现关系，而且类可以基层一个类的同时实现多个接口

接口与接口之间是继承关系

代码体现：

abstract class Student<span style="white-space:pre">	</span>//定义一个抽象类
{
abstract void study();<span style="white-space:pre">	</span>//study抽象方法
void sleep()<span style="white-space:pre">	</span>//sleep方法
{
System.out.println("sleep");
}
}
interface Running<span style="white-space:pre">	</span>//定义一个接口
{
void run();<span style="white-space:pre">	</span>//接口中的方法
}
class Lisi extends Student implements Running//继承和实现接口
{
void study()<span style="white-space:pre">	</span>//复写父类中的study方法
{
System.out.println("study");
}
public void run()<span style="white-space:pre">	</span>//复写Running接口中的run方法
{
System.out.println("run");
};
}
class InterfaceDemo
{
public static void main(String[] args)
{
Lisi ls = new Lisi();
ls.sleep();
ls.study();
ls.run();
}
}

执行结果：



抽象类和接口的区别：

1、抽象类只能被继承，而且只能单继承
接口需要被实现，而且可以多实现
2、抽象类可以定义非抽象方法，子类可以直接继承使用
接口中都有抽象方法，需要子类去实现
3、抽象类使用的是 is a 关系（继承，子类is a）
接口使用的是 like a 关系（接口，子类like a）

4、抽象类的成员修饰符可以自定义
接口中的成员修饰符是固定的，全都是public
5、抽象类重定义的是体系结构的共性内容
接口中定义的是对象的扩展功能