javaOOP

  OOP，Object Oriented Programming，即面向对象编程。

  面向对象的特征包括抽象、继承、封装、多态四个方面。

1.抽象：

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.封装：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

4. 多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

对象：就是一件东西, 是任何存在是事物都是对象，一切皆对象。

          对象在业务逻辑上是一个事物个体

          对象在本质上是结构化数据

          对象的每个数据成员称为对象属性（实例变量）

类：是对象的类型，是名词概念，

      本质上是对象的数据结构定义

      类中声明的对象的属性

    

    对象属性在类中声明，运行期间在堆内存中分配对象（对象属性）

    

引用：引用变量，业务逻辑上引用对象的代词，本质上存储的值是

   对象的首地址。通过首地址间接引用了对象。

   引用类型变量的值，不是直接的对象，是通过地址间接访问对象。

   引用本身不是对象。

   

方法： 对象的行为（功能）

   如：方块的移动（行为）

   方法的行为（功能）的实现是利用算法操作对象数据实现

对象：“存在”的事物，本质是结构化“数据”

  如：一个窗口框（位置，宽高等），一个面板（大小），

    一个T型方块(4个格子)，一个小格子（行 列 颜色）

对象的属性（对象的数据），也称为：实例变量

类：用类创建对象，需要先声明类，类是对象的抽象结构定义

　对象的属性是定义在类中的。

使用new运算调用构造在堆中分配内存创建对象。

  对象都在堆（内存）中创建。

  

构造器：创建并且初始化属性的过程。

  名称与类名一致，不能声明返回值值。可以有参数，参数是创建对象

  的前提条件。

方法：对象的行为：moveDown（）

  方法是业务功能的体现，本质是利用算法操作数据（对象）实现。

   

继承：被继承的类型是父类型（Super Class）继承类型是子类型

  (Sub Class) 

  如： T(Sub Class) 型方块继承了 Tetromino(Super Class)

    (4格方块)

 

 1) 子类继承父类中所有可继承资源 

   属性  如： cells

   方法（私有除外）如： moveDown()

   所有子类共享了父类的方法.

 2) 私有方法不继承，构造器不可继承

 3) 父类可以定义引用子类型实例, 向上造型

    Tetromino t = new I();

    Tetromino t = new T();

    

    注意: Java 按照"变量类型"检查是否调用方法.

 4) 子类型可以利用重写(覆盖)修改父类行的方法.

   如: paint() 方法, 修改了系统默认的绘制功能.

   重新的方法,调用的是子类型对象的方法(动态绑定)

 5) 属性是根据变量类型进行访问的

 6) 默认构造器现象

 

 

 重载与重写 的区别 

 重写: 是子类型定义与类型"一样的方法",目的子类修改父类的方法! 

    最重要的目的是 "修改"! 修改以后,在运行期间执行子类对象的方法

        父类型的方法被替换掉了(修改了).

  语法: 1) 子类方法名与父类一样, 参数相同

       2) 修饰词可以放大, 异常可以具体化(小类型)

       3) 父类的私有方法, 不能继承, 就不能被重写!

       4) 运行期间动态调用对象类型的方法

 重载: 是类中(含父子类型) 方法名一样,功能类似,参数不同的方法

   语法: 1) 方法名一样, 参数列表不同的方法

       2) 目的是使API的设计更加优雅

       3) 根据方法名和参数的类型调用对应的方法 

    重载的方法:

      println(int);   println(65);//65 

      println(char);  println((char)65);//'A'

      println(double);

      

访问控制（访问修饰）: 控制属性、方法、类的可见范围

  public: 修饰类，属性，方法， 构造器，内部类等

    在任何地方都可见 

  protected：只能修饰类的成员，在类体中使用，在当前package

    中可见（很少使用package作为访问范围），保护的成员主要留给

    子类使用的资源

   默认的：当前package中可见，很少使用

  private： 只能修饰类的成员，在类体中使用，是彻底封装，

   仅在类内部可见。

使用原则：尽可能私有。留给子类使用保护。减少使用公用，默认的

  几乎不使用。

  

  常见方式：私有属性，公用访问方法（get set 方法）。

  

Java 源文规格

  package {0,1}

  

  import {0,n}

  

  public class {0, 1} 只能有一个公有类！文件名与公有类名一致

  

  class {0, n} 一个文件中的多个类都是默认的。

  

  如果 没有公有类，文件名与任意类名一致。

  只有公有类才能在其他包中访问，默认类只能在当前包中访问！

  

 一般情况下：一个文件一个公有类！ 

static 静态的，可以修饰类的成员，在类体中使用

   可以修饰 属性，方法，代码块

   静态的资源都是属于类的，

   静态属性：是属于类的属性，在类加载期间初始化，并且只有一份

   如：图片素材只加载一份就够了。

  静态方法：是属于类方法，使用类名调用，经常作为工具方法、

  工厂方法，静态方法没有隐含参数this，与当前对象无关，不能访问

  当前对象（this）的方法、属性

 

 静态代码块：在类中声明，在类加载期间执行，只执行一次

 用于加载 一次的静态资源。如：图片素材   

   

final 最终的

  final class 不能被继承了

  final 方法  不能被重写

  final 变量 用的多，“final变量”只能初始化不能再修改了

  

  final int a = 5;//变量a的值不能再次修改

  //ary 是引用变量，值是地址值，通过地址间接引用了 数组

  final int[] ary = {5,6};//变量ary的值不能再改了

  ary = new int[3];//编译错误

  ary[0]+=3;

static final 常量

  定义软件中，不变化常数：CELL_SIZE=25

  命名：使用全大写的命名，多个单词下划线隔开

  

  区别：常量 与 字面量

对象数组：元素是对象的数组，实际上 元素是引用类型变量

  Cell[] cells = new Cell[4];//创建数组，但元素是null

  Cell[] line = new Cell[10];//创建数组，但元素是null

  

  cells = new Cell[]{new Cell(0,4), new Cell(0,3),

  new Cell(0,5), new Cell(1,4)};

 

  二维数组本质是一维数组

  

  抽象类

   业务方面：表达了抽象的概念，与具体相反

     抽象概念包含抽象行为，如：饮料一定可以打开，由具体饮料类型

     决定。

   语法方面：

   1）使用abstract 关键字定义抽象类

   2) 抽象类中可以定义 抽象的方法

   3）抽象类可以定义变量，引用子类型对象

   4）抽象类不能直接创建对象

   5）抽象类只能被继承

   6）继承抽象类，必须实现全部的抽象方法

   

   Tetromino 4格方块 就应用是抽象类！

   假如直接4格方块，是没有具体的方块格子的。

    移动的方法是不能够执行的

.metadata 是eclipse的配置信息保存目录 

 

 删除 /home/soft01/workspace/.metadata

 

 cd /home/soft01/workspace

 ls -a  查看隐藏文件

 rm -rf .metadata

 

 要启动eclipse 重新导入(import 菜单) 项目

 

 

 

抽象类 

abstract： 抽象的

  1）使用 abstract 关键字声明的类。

  2）表示逻辑上的抽象概念, 如： 4格方块

  3）抽象类不能直接实例化

  4）抽象类只能被继承

  5）抽象类可以定义变量，引用具体类的实例

      抽象类的实例是多种多样的--多态现象

      如： 4格方块的具体实例是多种多样的！

  6）抽象类中可以定义抽象方法，代表必须由子类实现的抽象的功能

   抽象方法规范了子类的方法。  

     抽象方法：使用abstract关键字定义，有方法名，没有方法体

    必须由子类实现的方法。

   抽象类： TimerTask 规范了子类必须实现run() 方法。

   实现Timer API与使用者代码的约定。 

    

接口 interface

 1）是纯抽象类，接口中只能定义抽象方法，和常量

 2）子类可以实现（implements）多个接口。就是Java中多继承现象

 3）接口可以定义变量 引用子类型实例

 4）接口也用于定义软件的规约。

内部类

  1）在类内部，或者方法中定义的类

  2）使用目的，是为了封装类的定义范围，在类内部使用

  

  

  软件中类：

  1）公有类 ： 任何地方都可见

  2）默认类（同包类）：当前包中可见

  3）内部类：类内部

  4）匿名内部类：当前方法中

匿名内部类--匿名类

  1）语法简洁:  new Xoo(){}

  2) 是在方法中定义的内部类，作用域是当前方法。

  3）内部类，匿名类，都会编译为一个独立的.class

  4) 常用匿名类在方法中简洁的实现接口或者抽象类。

  5）匿名类中的方法经常被回调执行

    

    如下代码，run（）方法被定时器timer，在适当时候，执行 

   实际上是将run方法教给了Timer，由Timer在时间合适时候，

   被Timer回调执行。

  Timer timer = new Timer();

timer.schedule(new TimerTask(){

public void run(){

System.out.println("HI"); 

}

}, 0, 1000);