面向对象程序设计讲解.doc

java面向对象程序设计讲解
面向对象程序设计思想。
一、 何为对象，何为类？
二、 对象的创建和使用。
三、 命名规则
四、 构造方法
五、 方法的重载
六、 this关键字
七、 static关键字
八、 类的继承
九、 方法的重写
十、 super关键字
十一、 多态机制
十二、 抽象类
十三、 final关键字
十四、 接口（interface）

面向对象的程序设计思想：

例如五子棋，面向过程的设计思路就是首先分析问题的步骤
1、 开始游戏 2、黑子先走 3、绘制画面 4、判断输赢 5、轮到白子走 6 绘制画面 7、判断输赢 8、返回到第2步 9、输出最后结果
再把上面每个步骤分别用c中的函数来实现，问题就解决了。

面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为：
1、 黑白双方，这两方行为时一模一样的
2、棋盘系统----负责绘制图画
3、规则系统----负责判断，如是否犯规、输赢等。

第一类对象（玩家对象）负责用户的输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定！

一、什么事对象？什么又是类？
我们周围的世界可以看成是由各式各样的对象组成。例如在学校中中有学生、教师、教室、课程、班级……这个组成元素都是对象。然而现实世界中的对象很多很多，比如说学校里有好多个学生，每个学生都是一个对象。而类就是具有共性的一类对象！如某个学生就是学生类中的对象！
二、类和对象的创建和使用
1．使用class来创建一个类
2．使用new来创建一个对象
3．使用 （对象名）.（方法名字）来调用对象的方法
4．使用 （对象名）.（属性名字）来访问对象的属性
举例 说明 Person.java
public class Person{ //使用class来创建一个类
String name; //定义一个字符串变量
int age; //定义个整形变量

void walk(){ //定义一个方法
System.out.println("正在走路。。。");
}

public static void main(String[] args){
Person p = new Person(); //使用new来创建一个对象
p.name = "志超"; //对象名.变量名 来调用类的属性!
p.age = 21;
System.out.println("name:" + p.name + "\n" +"age:" + p.age ); //打印语句
p.walk(); // 对象名.变量名 来调用类中的方法！
}
}
三、命名规则
1．类的首字母大写 2、变量名和方法名字的首字母小写 3、使用驼峰标示
例如上一个例子当中 public class Person 的Person 首字母就大写了。而方法和变量名首字母就用小写。

四、构造方法
1．使用new + 构造方法创建一个对象
（1）构造方法的名字和类的名字一致，并且没有任何返回值。
（2）当你创建一个class的时候，java编译器会自动给你创建一个无参数的构造方法
（3）一旦你要定义了构造方法，系统将不会在给你添加新的构造方法
class Person{
String name; //定义一个String类型的变量
int age; //定义一个int类型的变量

Person(){ //这是一个空的构造函数
}

void walk(){ //定义walk方法
System.out.println("正在走路......");
}

五、方法的重载
方法名相同但是参数不同的方法称为方法的重载
用途：当需要计算的参数不同，但是调用的方法名相同的时候，就用到了方法的重载。
比如计算一个数的立方，这个数可以是int类型，也可以是double类型，那么在设计方法的时候就需要设计两个方法，但是两个方法又都是计算一个数的立方。为了使方法调用着方便，我就在这就定义两个方法名字相同，参数和返回值不同的方法。这就形成了方法的重载。重载的方法可以有多个。
举例子：MethodOverloading.java

/** 一个应用程序，用来演示方法的重载 */

/** MethodOverloading类，在该类中定义cube方法，该方法被重载 */
public class MethodOverloading{

/** 计算一个长整数的立方 */
int cube(long l) { //这个int cube( )方法和下面 的 double cube( )构成重载
return l*l*l;
}

/** 计算一个双精度数的立方 */
double cube(double d){
return d*d*d;
}

/** 定义main方法 */
public static void main(String args[]){
MethodOverloading obj=new MethodOverloading();
//创建一个MethodOverloading类的对象
System.out.println("the cube of 5 is "+obj.cube(5)); //输出5的立方
System.out.println("the cube of 0.9 is "+obj.cube(0.9));// 0.9的立方
}
}
六、this关键字
this指当前对象的引用，有时候解决方法中成员变量和参数重名的的情况
public class Person{
String name; //定义一个String类型的变量
int age; //定义一个int类型的变量

Person(){ //这是一个空的构造函数
}

Person(String name,int age){ //这是一个带参数的构造函数。且两个构造函数形成了重载
this.name = name; //this 指代的就是当前的Person对象
this.age = age; //使用this关键字标识成员变量，以区别于同名参数。
}
}

七、static关键字
1、在类中使用static声明的成员变量为静态成员变量，static成员变量只有一份。它不 同于其他的变量，每new一个对象出来就会有一份，而static声明的变量无论new多少个对象出 都只有一份
2、静态成员变量用（类名）.（变量名）来访问，因此静态成员变量也可以称为类变量

八、类的继承
Java中使用extends 关键字来实现类的继承。通过继承，子类拥有了所有父类的属性和方法。
Java只支持单继承，不允许多继承
Extends.java
//定义一个Person类
public class Person{
String name;
int age;

void walk(){
System.out.println("正在走路......");
}
}
//类Students继承类Person ，这里我们叫Student为子类，Person为父类
class Students extends Person{
//学生类继承了人类，人类所有的属性和方法在学生类中都拥有。
}

class Extends{
public static void main(String[] args){
Students zhiChao = new Students();
zhiChao.walk();
}
}
九、方法的重写
1子类可以根据需要对父类中的方法进行重写
2 重写的方法和被重写的方法要有相同的方法名字，参数列表和返回类型。
3 为什么要对父类的方法进行重写呢？
比如说上面的例子中，子类继承了父类的方法，但是子类对父类的方法必不满足，需要修改父类中的方法。那么就用到了方法的重写！
例子：Extends.java中讲解
class Students extends Person{
//学生类继承了人类，人类所有的属性和方法在学生类中都拥有。但是呢，学生类不满足父类中的walk( )方法。就需要对父类中的方法就行重写，方法如下！
void walk(){ //对父类的方法进行了重写
System.out.println("拿着本书走路......");
}

}

十、super关键字
前面我们讲过this关键字指当前类。
super关键字指当前类的父类！
class Students extends Person{
//学生类继承了人类，人类所有的属性和方法在学生类中都拥有。
Student( ){ //这是Student的构造方法
super( ); // 这是Person中的构造方法，super指代的就是当前类的父类
}
}
十一、多态（动态绑定）---java的最核心机制
Dynamic.java

class Person{
String name;
int age;

void walk(){
System.out.println("正在走路......");
}
}

class Students extends Person{
//wolk()方法的重写
void walk(){
System.out.println("学生拿本书在路上走......");
}
}

class Teachers extends Person{
//wolk()方法的重写
void walk(){
System.out.println("老师背个包在路上走......");
}
}

class Dynamic{
public static void main(String[] args){
Person p1 = new Students();
Person p2 = new Teachers();
p1.walk();
p2.walk();
}
}
多态机制的三个必要条件：（1）继承 （2）重写 （3）父类对象引用指向子类对象！
十二、抽象类
1． 用abstract修饰的类为抽象类，用abstract修饰的方法为抽象方法
2． 抽象方法只能声明，不能实现
3． 含有抽象方法的类必定为抽象类
4． 抽象类不能被实例化（也就是说抽象类不能new出对象）

十三、final关键字
final的变量不能改变值，final的方法不能被重写，final类不能被继承
十四、接口（interface）
interface 是一种特殊的抽象类
1、里面多有的方法都是抽象方法，并且都是public型的！
2、所有的成员变量都是public的static的final的
3、接口和接口之间可以继承；类和类之间也可以extends；接口和类之间sorry，它们只能实现（implements）
4、一个类可是implement多个接口。多个类也可以implement一个interface