黑马程序员-java 面向对象【个人总结】

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

首先说下什么是面向对象，我的理解可以理解成通过把生活中的某些事物可以看作一个个的对象，进行处理的思想，java编程理念万物皆对象，而在设计的时候其实就是在管理和维护对象之间的关系，可能理解的有些片面，望见谅。
对象：现实中的事物这个个体。
类：对某个对象的描述，描述了对象的属性和行为。
属性：对应类中的成员变量。
行为：对应类中的成员函数。
其中，面向对象的特征如下：
一．封装(encapsulation)

定义：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
目地：就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。
优点：将操作隐藏，提高了安全性；对功能进行封装，提高了复用性。
封装原则是：将不需要对外提供的内容都隐藏起来，对外只提供开放的访问方法。
其中我们可以通过private（私有）权限修饰符来实现封装（private只是体现封装的一种方法。）

class Person{
private String name; //peivate进行了简单的封装，只有本类可以调用
publicvoid SetName(String name){//这里需要知道的是，java函数是一个最小的封装体。
this.name = name;
}
public String getName(){
returnname;
}
publicstaticvoid main(String[] args) {
Personp = new Person();
//这里不能使用p.name来访问name属性，通过了private私有化，只能通过对外开发的方法，进行调用
p.SetName("小红");
System.out.println("打印>>"+p.getName());

}

}

二．继承(inheritance)

定义：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。
目的：让类与类直接产生关系，进行连接；提供了多态的前提。
优点：由于提取了共有部分做父类（超类），所以提高代码的重用性。
继承原则：Java只支持单继承，不允许多继承（多个父类中有相同成员，会产生调用不确定性）。一个子类只能有一个直接的父类，一个父类可以派生出多个子类。
其中，使用extends关键字来实现类的继承，并且子类可以直接访问父类中的非私有的属性和行为。
Java支持多层继承，也就是形成了一个继承体系。
• class A{}
• class Bextends A{}

• class C extends B{}
定义继承需要注意：
•不要仅为了获取其他类中某个功能而去继承
•父类中的功能是不是该类都应该具备
•类与类之间要有所属关系，A是B的一种。即：A
extends B

class Person{
String name;
String color;
}
class Black extends Person{
// 可以使用Person的所有非私有的属性或方法，如：name、color
void speak() {
System.out.println(name + "说：我是"+color+"皮肤的人！");
}
}
class Yellow extends Person{
// 可以使用Person的所有非私有的属性或方法，如：name、color
void speak() {
System.out.println(name + "说：我是"+color+"皮肤的人！");
}
}
publicclass Demo {
publicstaticvoid main(String[] args) {
Black b = new Black();
b.name = "黑人";
b.color = "黑色";
b.speak();

Yellow y = new Yellow();
y.name = "黄种人";
y.color = "黄色";
b.speak();
//这里把Yellow和Black的两个共有属性name和color提取出来，放在了Person类，他们之间产生了关系，那么Person为超类，Yellow和Black为子类。
}
}

继承出现后，代码上也有一些特点：
1，变量。
当子父类中定义了相同的名称的成员变量，子类要使用父类中的同名变量时，需要使用关键字super来区分。
2，函数。
子类可以直接访问父类中非私有的成员函数。
特殊情况：当子类中定义了与父类一模一样的方法时，会发生覆盖操作（大多指的是非静态方法），最终会运行子类的方法，父类相当于被覆盖了。
三．多态(polymorphism)
定义：某一类事物存在的多种形态。
如：人类可以分为男人和女人，那么我们可以看作人类有两种形态，那么就是男人和女人。
代码表示：

class Person{
//内容。。。
}
class Man extends Person{
//内容。。。
}
class Woman extends Person{
//内容。。。
}

构成多态的条件：1.要有继承 2.要有重写 3.父类应用指向子类对象。
1，多态的体现
父类的引用指向了自己的子类对象。
2，多态的前提
必须是类与类之间有关系。要么继承，要么实现。
通常还有一个前提：存在覆盖。
3，多态的好处
多态的出现大大的提高程序的扩展性。
4，多态的弊端：
虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。
其中，可以使用instanceof进行多态类型的判断，格式：对象 intanceof
类型(类类型接口类型)
如下：

publicstaticvoid method(Person a){
if(a instancesof Man){  // instancesof用于判断对象的具体类型，只能应用于引用数据类型判断。
//内容。。。
}elseif(a instancesof Woman){
//内容。。。
}
}

多态中的数据转型问题：
类型提升（向上转型），如下：Personp=new Man();
这里作用就是提高程序扩展性，但是限制对特有功能的访问。
向下转型，如下：Man m=(Man)p;
这里的作用是为了使用子类中的特有方法。

注意：

1. 不能出现的操作，就是将父类对象转成子类类型。

2.我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

3. 多态自始至终都是子类对象在做着变化。

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：

无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：

无论编译和运行，都参考做左边。

下面举一个多态的完整的例子：

/*
基础班学生:学习，睡觉。
高级班学生:学习，睡觉。
可以将这两类事物进行抽取。
*/
abstractclass Student
{
publicabstractvoid study();
publicvoid sleep()
{
System.out.println("躺着睡");
}
}

/*
一个工具类
*/
class DoStudent
{
publicvoid doSome(Student stu)
{
stu.study();
stu.sleep();
}

}

class BaseStudent extends Student//基础班学生：
{
publicvoid study()
{
System.out.println("basestudy");
}
publicvoid sleep()
{
System.out.println("坐着睡");
}
}
class AdvStudent extends Student  //高级班学生
{
publicvoid study()
{
System.out.println(" advstudy");
}
}
class  DuoTaiDemo3
{
publicstaticvoid main(String[] args)
{
DoStudent ds = new DoStudent();
//下面是多态的两种提现形式
ds.doSome(new BaseStudent());
ds.doSome(new AdvStudent());
}
}