面向对象基础学习心得

一、类与对象

类是用来对一组具有相同特性事物的描述，而对象就是类的实例，类用来描述对象，就像一座大楼与楼的设计图的关系，盖成一座大楼需要一张设计图来确定这座楼有多高，有多大，一层有几个房间等。万物皆对象。
例如：

//一个描述人的类
public class Person {private String name;  //人的姓名private int age;     //人的年龄private String sex ;   //人的性别public void spaek() {System.out.println("说话");}
}

上面的代码，是一个关于人的类，类中描述了一个人的属性如姓名，年龄；还有人的一个动作说话，可以说，通过这个类，我们就能简单的得到一个‘人’。

Person people1  = new Person(); //java中通过new关键字可以创建一个对象。
people1.speak(); // 通过对象可以调用该对象的speak方法。

创建一个对象后就可以调用其中的成员变量和方法，要注意成员变量的修饰符，public(在所有的类中都能访问)，private(只能在自身类中访问，也不能在子类中访问)，protected（只能被自身类，子类和同一包中的类访问），一般常用的就这三个。在上述代码中，调用了speak方法，其修饰符public，说明可以任意类中的访问，而name，age属性，都是私有的private，只能在本类中访问，如果需要访问，我们可以在Person类设置return方法来返回，这样可以保护类中的数据，起到封装的特性，如：

public String getName(){return this.name;
}

二、构造方法

构造方法就是对对象的初始化，就是在new对象时，使对象当出现时就自带有一些属性值，比如说一个人，刚出生是父母一般都会起好名字，那么我们为什么不在创建对象时就给对像的名字赋值呢？这就需要构造方法。

public class Person {private String name;protected int age;//构造方法，需要传入名字。public Person(String name) {this.name = name;}public void spaek() {System.out.println("说话");}public String getName(){return this.name;}
}

构造方法是与类同名，公共的，没有返回值的方法，不用用户调用，会在创建对象是自动调用。

Person people1 = new Person("小王");
people1.getName(); //调用people1的getName方法得到name的值  此时name的值同过构造方法的赋值，为“小王”。

三、重构

上面我们讲解了构造方法，那么问题来了，如果一个人一出生还没有起好名字，那怎么办呢？这就需要说到方法的重构了。就是方法名称一样，返回值一样，就是方法的传参不一样。创建对象是根据传入参数的个数。类型的不同，来调用不同的构造方法。不止是构造方法，成员方法也能重构（注意：重构时的参数要么要在个数上不同，要么要在传入参数的类型上不同）。

public class Person {private String name;protected int age;public Person() {   //没有参数的构造方法this.name = "无名";}public Person(String name) {this.name = name;}public void spaek() {System.out.println("说话");}public String getName(){return this.name;}
}

当我们调用时，可以传入不同的参数来创建对象。

        Person people1 = new Person("小王");  //创建一个名字为小王的人，调用有参构造方法。Person people2 = new Person();   //创建一个没有名称的人，调用无参构造方法System.out.println(people1.getName()); // 输出为  小王System.out.println(people2.getName()  //输出为  无名

四、封装

封装、继承、多态是面向对象的三大特性，现在我们来说封装，封装就是每个对象都包含他能进行操作所需要的所有信息，把这些信息包装在类中，这样就实现了封装。

封装有很多好处，第一、良好的封装能够减少耦合，第二、类内部的实现可以自由的修改。

类的封装就好比一座房子，里面摆放了精美的家具，如果没有围墙，那房子内的物品任何人都可以看或者改动，由于有了围墙（封装），房屋内的物品就不会被外人动了，但是如果没有门窗，那么房子就成了一个铁盒子，就算里面的东西再怎么豪华，再怎么精美，人不能住进去，也没用。所以要有门窗，使主人能够住进来。就像刚才的那个Person类，其中的name属性是私有的，不能够在类外访问，我们加了个getName()方法，是我们能够访问到name 的值，这就是封装对象暴露在外的属性和方法。

五、继承

继承就是子类继承父类，会继承父类的非private的成员变量和成员方法，子类也能拥有属于自及的成员变量和成员方法，并且能够重写父类的成员方法。
例如：人是一种总称，但是人有分为中国人，美国人，德国人等，各个不同国家的人拥有相同的属性，如姓名，性别，年龄等，那么我们可以使各个国家人的类继承人的类，人类中包括姓名、性别、年龄等一些共有属性。而各个国家的人类中可以有一些输入自己的一些行属性等。

class Person {public String name;public int age;public Person() {this.name = "无名";}public Person(String name) {this.name = name;}public void spaek() {System.out.println("说话");}public void run () {System.out.println("跑");}
}
//继承父类
class Chinese extends Person {//构造方法，super()调用父类的方法public Chinese(String name) {super(name);}//子类特有的方法，中国人唱豫剧public void sing() {System.out.println("豫剧");}}

在上述代码中，有Chinese子类继承了Person父类，(需要说明的是，在子类中的构造方法，如果父类中有构造方法的重构，而父类中没有无参数的构造方法的声明，那么在子类中的构造方法必须指定调用那个父类的构造方法，否则，将会出错。)会拥有父类的所有成员和方法，而在子类中则增加类中国人特有的京剧。如果我们在main函数中new出Chinese的对象，那么是可以调用父类的成员属性和方法的。

如果之后我们想加入美国人、德国人等，只需要创建相应的类，然后继承Person类，同样可以拥有name，age等属性，以此，提高了代码的可读性、和复用性。

使用继承是需要注意的是，两事物A和B之间的关系必须是A包含B，那么才能让B继承A。

六、多态

现在假设要举行一场跑步运动会。各个国家的热都要参加，要怎样才能让不同国家的人同时赛跑呢，那么这就用到了多态，多态就是不同的对像可以执行相同的动作，就拿豫剧来说吧，有一位非常出名的老父亲，演豫剧演的特别好，他儿子每天跟老父亲学习，也学是非常像，有一天，老父亲生病了，上不了台表演，他儿子可以替父亲上台表演，因为他们表演的特别像，再因为在台上化了妆，观众根本认不出来。这就是多态的原理，声明对像是声明父类对象，new对象时new出子类对象。

class Person {public String name;public int age;public Person() {this.name = "无名";}public Person(String name) {this.name = name;}public void spaek() {System.out.println("说话");}public void run () {System.out.println("跑");}
}class Chinese extends Person {public Chinese(String name) {super(name);}public void run(){System.out.println("我是中国人"+this.name+"，我参加运动会");}public void sing() {System.out.println("豫剧");}
}public class RunSport {public static void main(String[] args) {Person chinese = new Chinese("小王"); //用父类指向子类对象。chinese.run(); // 调用子类中重写后的run方法 ，输出 "我是中国人小王，我参加运动会"}
}

使用多态时要注意 1.子类以父类的身份出现，2. 子类的工作方式以自己的工作方式实现；3. 子类以父类的身份出现时，子类特有的属性和方法不可以使用(子类中重写父类的方法可以使用)；
下面，我们来运用多态来实现运动会。我们先来增加几个国家：

//美国人
class American extends Person {public American(String name) {super(name);}public void run(){System.out.println("我是美国人"+this.name+"，我参加运动会");}}//德国人
class  German extends Person {public  German(String name) {super(name);}public void run(){System.out.println("我是德国人"+this.name+"，我参加运动会");}}俄罗斯人
class Russians extends Person {public Russians(String name) {super(name);}public void run(){System.out.println("我是俄罗斯人"+this.name+"，我参加运动会");}}

我们用Java中的容器来存储参赛人员，来实现比赛。

public class RunSport {public static void main(String[] args) {ArrayList<Person> athletes = new ArrayList<Person>();athletes.add (new Chinese("小王"));athletes.add (new American("迈克"));athletes.add (new German("约翰"));athletes.add (new Russians("鲍里斯"));for (int i = 0; i < athletes.size(); i++) {athletes.get(i).run();}}
}
/* 运行结果
我是中国人小王，我参加运动会
我是美国人迈克，我参加运动会
我是德国人约翰，我参加运动会
我是俄罗斯人鲍里斯，我参加运动会
*/

这就是不同的对象可以执行相同的动作，但要通过他们自己的代码实现来执行。

七、抽象类

在上述代发中我们可以发现Person类根本不用实例化，那么我们就可以把他设为抽象类，抽象类是不能实例化的。把需要重写的方法设置为抽象方法。

abstract class Person {public String name;public int age;public Person() {this.name = "无名";}public Person(String name) {this.name = name;}//普通方法，可以被继承，也可被重写public void spaek() {System.out.println("说话");}//抽象方法，在子类中必须重写public abstract void run ();
}class Chinese extends Person {public Chinese(String name) {super(name);}//重写父类的抽象方法，以自己的方式实现public void run(){System.out.println("我是中国人"+this.name+"，我参加运动会");}}

抽象方法在使用时应该注意：

抽象类不能实例化
抽象方法是必须被子类重写的方法
如果父类中拥有抽象方法，那么父类必须被声明称抽象类

八、接口

根据上述例子，当一个国家或几个国家的人拥有特别的功能时怎么办呢，有人会说再各自国家的子类中定义各自特殊的方法，但是那样的话会使代码变得杂乱，使用接口是让用户和其他开发人员更容易理解他人的代码。
接下来我们以我们的国球为例，假设一个人会打乒乓球，那么我们先要有一个打乒乓球的接口，声明接口是需要注意，接口中不允许出现任何成员的执行方式，不能声明无值得成员变量，若定义成员变量是赋初值，那么这个成员变量会默认声明为public static final 类型。

interface  PingPong{//声明打乒乓球方法public void play();
}

那么在子类中就需要实现该方法

class Chinese extends Person implements PingPong{public Chinese(String name) {super(name);}public void run(){System.out.println("我是中国人"+this.name+"，我参加运动会");}public void sing() {System.out.println("豫剧");}//实现接口中方法public void play() {System.out.println("打乒乓球");}
}

有了这个接口，当在出先一个人会打乒乓球时，我们直接让这个人继承PingPong类就行了。
现在来说一下接口和抽象类的区别，抽象类可以给出一些成员变量的实现，而接口不能包含有实现，抽象类的抽象成员可被子类部分实现，接口的成员需要需要实现类完全实现。

参考文献《大话设计模式》程杰著