面向对象的程序设计概论

最新推荐文章于 2024-09-27 00:45:01 发布

fuguocan0571

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量398

点赞数

分类专栏： java学习文章标签： class java interface methods string sockets

本文链接：https://blog.csdn.net/fuguocan0571/article/details/7998362

版权

java学习专栏收录该内容

1 篇文章 0 订阅

订阅专栏

什么是一个对象？
对象是理解面向对象的技术的关键
现在看看周围，你将找到很多例子关于真实世界对象：你的狗你的桌子你的电视机你的自行车
真实世界的对象都有两个特点：他们都有属性和行为。狗拥有的属性（名字，颜色，品种，饿）
和行为（叫，取东西，摇尾巴）。自行车同样有属性（齿轮，踏板节奏，达到速率）和行为
（变换齿轮，变化踏板节奏，变速）。识别真实世界中对象的属性跟行为是进行面向对象编程的一个好方法

花一点时间观察周围的真实世界的对象，对于每个对象，问自己两个问题，这个对象的属性是什么，这个对象
在现实世界中有什么行为？然后写下你的观察所得，当你这样做的时候，你会发现周围的对象是错综复杂的，
你的抽屉有两种行为--开着关着，两种行为--打开和关闭。你的收音机却有开，关，当前的音量，当前的
调频等状态，以及打开关闭调频道，增大或者减少音量等行为他们有可能还包含着别的对象，这些真实
世界的发现都可以有面向对象的编程来实现。

软件中的对象跟现实中的对象是很相似的：他们都有属性跟行为两部分组成，属性有程序中的变量表示，行为则是由
方法来实现，方法操作这个对象的属性并且成为对象与对象之间通信的主要机制。隐藏内部属性并且通过对象的方法来相互交互
是一种面向对象的方法叫做封装---面向对象编程的根本原则。

例如一个自行车模型的对象：
属性：currentSpeed = 18mph ，currentPedalCadence = 90rpm , currentGear = 5th gear;
方法：changeGears(); Brake(); changeCadence();
这个对象控制外面的世界如何来使用它，如：这个自行车只有6个gears changeGears()方法如果改变的gears小于0或者大于6
就不能执行

封装对象有很多好处，包括：

1.模块化：这个对象的源代码可以独立于其他对象的源代码，一但创建对象，一个对象可以很简单的融入到系统中，也方便并行开发

2.信息隐藏：外面只能与该对象的方法进行交互，详细的实现对外面的世界隐藏。

3.代码复用：如果一个对象已经存在（可能是另外一个软件开发开发者编写），你就可以使用这个对象在你的程序里。这个
对象是已经被专家实现测试调试过的，复杂的，具体任务的对象，你不用关心他怎么实现 just use it！

4.可插拔的可修复替代的：如果一个具体的对象出现问题，你可以从你应用中简单移除，并且插入别的好的同一类型的对象
这个现象在生活中也常见，如一个机子的螺丝钉断了可以再换一个新的螺丝钉 not the whole machine！！

什么是类？
在现实世界中，你经常能发现很多对象都是同一类型。例如，有成千上万的另外的自行车存在，他们都具有同样的制造方式
和同样的模型，每一辆自行车都有相同的蓝图并且都用相同的部件。在面向对象的方法里，我们说你的自行车是一个实例，是
自行车这种对象类型的一个实例。
下面就是一个Bicycle类：

class Bicycle {

   int cadence = 0;
   int speed = 0;
   int gear = 1;

   void changeCadence(int newValue) {
       cadence = newValue;
   }

   void changeGear (int newValue) {
       gear = newValue;
   }

   void changeSpeed(int newValue) {
       speed = newValue;
   }

   void speedUp(int increment) {

       speed += increment;
   }

   void printStates() {
       System.out.println("cadence:" +
           cadence + "speed:" +
           speed + "gear:" + gear)
   }
}

java的语法可能对你来说看起来是新鲜的，但是这个类的设计就是基于前面关于自行车对象的讨论. 这个变量 cadenece，
speed 和 gear 代表着自行车的属性，这些方法(changeCadence, changeGear，speedUp等)都是用来跟外面的世界进行交互的

你可能发现这个Bicycle类没有包含一个main方法，这是因为这不是一个完整的应用。他只是一个自行车的类，可以被用在一个
应用中.创建并且使用新的自行车类的权利是属于你应用中别的类的。

这里有个BicycleDemo class 它创建了两个不同的自行车对象并且调用它们的方法：
class BicycleDemo {

   public static void main(String[] args) {

       //create two different bicycle objects:
       Bicycle bike1 = new Bicycle();
       Bicycle bike2 = new Bicycle();

       //Invoke methods on those objects
       bike1.changeCadence(50);
       bike1.speedUp(10);
       bike1.changeGear(2);
       bike1.printStates();

       bike2.changeCadence(50);
       bike2.speedUp(10);
       bike2.changeGear(2);
       bike2.changeCadence(40);
       bike2.speedUp(10);
       bike2.changeGear(3);
       bike2.printStates();
   }
}

这个测试demo打印出两辆自行车最后的cadence speed 和gear：

   cadence:50 speed:10 gear:2
   cadence:40 speed:20 gear:3

什么是继承？

   不同类型的对象通常都会有一些共性。例如：山地车，公路车，儿童自行车，都拥有自行车的特点（speed cadence gear）
   当然他们各自有自己额外的特性使他们各不相同：儿童自行车有两个小轮子帮助儿童学习骑车，公路自行车有向下的把手，
   山地车有更粗的轮胎防止打滑

   面向对象的程序设计允许类从别的类那里继承相同的属性和行为，在这个例子里：Bicycle成为了父类，MountainBike，RoadBike
   等成为类它的子类，在java语言中每个父类可以有不限数量个不同的子类。

   创建一个子类的语法很简单。在你的类名之后加上关键字extends 已经想要继承的父类名称：

       class MountainBike extends Bicycle {

           //new fields and methods defining
           // a mountain bike would go here

       }

   这样子MountainBike这个类拥有Bicycle类所有的属性跟行为，还可以加上自己的属性方法使它独一无二。这个使得你的
   子类更容易阅读。注意，你必须确保每一个父类的属性跟行为的准确性，不然有问题的话每个继承他的子类都会有问题。

什么是一个接口？

   以前已经学习，对象通过暴露出来的方法来跟外界交互。方法就像对象跟外界的接口。比如电视机上的按钮，是你跟电视机
   对象之间的接口，你通过这个电源键来打开和关闭电视机。

   通常情况下一个接口是一组没有实现的方法。一个自行车类的行为，如果以接口的形式展现，就会像下面那样：

   interface Bicycle {

       // wheel revolutions per minute
       void changeCadence (int newValue);

       void changeGear (int newValue);

       void speedUp(int increment);

       void applyBrakes(int decrement);
   }

   来实现这些接口，你的类的名字应该改变下（是一个特别的牌子的自行车，如ACMEBicycle），然后你将使用implements
   关键字在类的申明里：

       class ACMEBicycle implements Bicycle {

           //remainder of this class
           //implementd as before
       }
   实现一个接口允许一个类变得更格式化，这些类里的行为在接口中提供，接口是一种类和外界合同，这个合同在编译器build
   阶段就已经实现，如果你的类要实现一个接口，被这个接口定义的方法必须在类成功编译之前就已经出现在他的源码中了。

   注意：如果要使ACMEBicycle类编译正确，必须在所有要实现的接口方法前加public。

什么是一个包？

   一个包是一个命名空间，用来组织相关的类和接口的集合。你可以理解成包是跟计算机上不同的文件夹类似，你必须保持
   HTML在一个文件夹图片在另外一个，脚本跟程序在别的一个。因为java程序可能有成千上外个不同的类，把相关的类跟接口放在一个
   包中可以使程序显得有组织。

   java平台提供了大量的class库（被分在不同的包里）适合在你的应用中使用，这些库简称API，不同的包都有不同的作用，如
   Socket包主要用来创建network相关的对象和sockets对象,GUI包主要用来创建图形相关的对象，不同包之间相互独立。
   后续会讲java的访问权限跟包也有关系。
   Java Platform API Specification 包含了完整的包接口类方法等在java SE 平台支持的库，作为一个java程序员，它将
   成为你最有用的reference 文件。

问题与练习：

   1. 真实世界对象都包含（属性）跟（行为）
   2. 一个软件的对象的属性是存在（对象的变量中）
   3. 一个软件中的对象的行为一个暴露通过（对象的方法）
   4. 对外隐藏内部数据，并且通过方法来与外界通信的形式我们称为数据（封装）
   5. 对同一类型的软件对象的概括我们称之为（类）
   6. 相同的行为可以被定义在一个父类并且继承它为（子类）用关键字（extends）
   7. 一个搜集方法并且没有实现的集合我们叫它（接口）
   8. 一个命名空间用来组织有关系的类和接口，这个namespace称为（package）
   9. API全称： Application programing interface

   在你周围发现一个对象并用java编写一个类

   class Pen {

       int length;
       int color;
       string brand;

       void write(string word) {
           System.out.println("write a" + word);
       }

       void changePenColor(int color){
           this.color = color;
       }

       void becomeLower(int len) {

           length = len;
       }

       void printStates() {

           System.out.println("length:" + length + "color:"
               + color + "brand" + brand);
       }

   }

   2.上面建的新类，创建一个接口来定义它的行为，然后要求你的类来实现它并且忽略一两个方法试着编译它看它发生了什么错误？

   interface Pen {
       void changePenColor(int color);

       void becomeLower(int len);

       void printStates();
   }

   class HeroPen implements Pen {

       public void changePenColor(int color) {
           //TODO:
       }
       /*
       public void becomeLower (int len) {

           //forget it!!!
       }
       */
       public void printStates() {

           //TODO:
       }

   }