java OOP技术

内容

1.“-Oriented”的含义

2.对象（Object）

3.类的用途：叙述软件对象

4.基类与子类的结构用途

5.IOC机制与Default函数

6.主动型API    VS  被动型 API

7 接口与类

1.“-Oriented”的含义

  英文翻译为面向，意味着一种信仰

Object-oriented 相信任何软件都是由对象所构成，而且Nothing else。

 总结 ：电脑语言的设计就简化了 ，写程序只要定义类别就行了。比如 电脑的安装给你主板 显示器 cpu（这就相当于对象了）就很容易安装了，假如给你的是一堆二极管呢，难度高很多

-Based 基于需求

-Driven 引导 

-Centered 一切软件开发的活动都围绕着架构，就像糖果和礼物都挂在圣诞树上一样的

 2.对象（Object）

 ▲ 对个人而言，所认识的东西皆是对象。例如 李白最清楚的对象是他的诗，每首诗皆是对象。至于当时外国的诗，他可能就不认识了。就不是他的对象了

 ▲ 一旦认识某样东西，就能说出其特点，并与别的对象比较 一番 。特点包括 特征（属性Attribute）和行为（Behavior）

▲软件的对象是由数据  Data（特征）和函数  Function（行为）组成

3.类的用途  ：叙述软件对象

▲类（Class）是群体（或集合），而对象是类中的一份子。对象和类的关系（IS A）

▲ 月亮（对象）是一个星球（类）

 ▲ 类是一群具有共同重要特性对象的集合，类的定义就是说明这群对象具有什么重要的特性。特性包括对象的特征（属性）和行为。软件中用数据表示特征（属性），函数表达行为。类之定义就是说明软件中的对象 应包含哪些数据和函数。

packeg my.project

Class Person{

private int age

private String name

public void sleep（）{

System.out.println（“sleeping”）；

}

}

Person就是我们新创的类别 ，将用来诞生对象。以描述人，生成对象如下

▲ new 关键字 生成 Person person=new Person（）；

▲  反射生成  Class objClass=Class.forName（“（my.project）包路径+（Person）类名”）； Person person=objClass.newInstance

通常写的程序都是静态的代码，就是编译之后能够确定执行顺序的就是静态，而动态是需要在运行的时候 才知道去执行的什么的是动态；总的来说就是事前知道的是静态，事前不知道的是动态，这样解释能否接受

▲  克隆生成 Person person1=new Person（）；Person person= person1.clone

new Person（）指令就诞生一个Person类的对象了

4.基类与子类的结构用途 

  一 表达继承

 ▲ 对众多对象加以分门别类，就可形成一个类的继承体系 例如对学校人员分门别类  Person （基类），Teacher（子类），Student（子类）

▲ class Person {

private String names;

private int age;

public void set_value(String name ,int a){

names=name;

age=a;

}

public int birth_year(){

  return 2016-age 

}

public void display(){

System.out.println(name+","+age);

}

}

class Teacher extends Person {

private double salary;

public void teacher_set_value(String na,int a,double sa){

set_value(na,a);

salary=sa;

}

public void print(){

display();

System.out.println(salary);

}

}  

class Student extends Person{}

▲  android

 public class okButton extends Button{

int width ;

int height;

//构造类的方法

public okButton(Context ctx){

super(ctx);

super.setText("OK");

super.setBackgroundResource(R.drawable.ok)

width=50;

height=50;

}

public int get_width(){

return width;

}

public int get_height(){

return height;

}

}

▲  使用 

 public class myActivity extends Activity{

@Override

public void onCreate(Bundle state){

super.onCreate(state)

LinearLayout layout=new LinearLayout(this);

layout.setOrientation(LinearLayout.VERTICAL);

okButton ok_btn= new okButton(this);

LinearLayout.LayoutParams param=new LinearLayout.LayoutParams(ok_btn.get_width(),ok_btn.get_height());

}

}

二 表达组合

 class Task implements Runnable{

public void run (){

int sum=0;

for(int i=0;i<=100;i++){

sum+=i

System.out.println("Result"+sum);

}

}

}

public class JMain{

public static void  main(String[]args){

Thread t=new Thread(new Task());

t.start();

}

}

java 提供了一个 Thread基类和一个Runnble接口 这2个元素就构成以个框架。框架的Thread基类会先诞生一个小线程 ，然后通过小线程透过Runnble接口呼叫（执行）Task类别的run（）函数

此时 main（）先诞生一个Task（）类别的对象，并且诞生一个Thread基础对象，接着执行t.start（）指令。这样main（）就呼叫Thread的start（）函数 ，start（）就产生一个小线程去执行run（）函数。

▲  class Task extends Thread{

public void run(){

or(int i=0;i<=100;i++){

sum+=i

System.out.println("Result"+sum);

}

}

public class JMain{

public static void  main(String[]args){

Thread t=nnew Task();

t.start();

}

}

三 .接口

 ▲Hook函数 用来接合2个东西的接口， 如果2个东西不同时间出现，则一方会预留虚空，给予另一边与未来时刻能以实体来填补空间，两者虚实相依，就密合起来了

 ▲ 变与不变的分离 将不变部分写在父类，变的部分写在子类

▲Hook函数 的java实现

 使用抽象（absract）函数或重写（overridable）函数来实现

interface IShape{

void template_paint(Graphics gr);

} //一般接口

public abstract class Shapr implements IShape{

public void temlate_paint(Graphics gr){

invariant_paint(gr);//画背景

hook_paint(gr);//画前景

}

pubilc void invariant_paint(Graphics gr){

gr.setColor(Color.black);

}//默认行为

abstract protected void hool_paint(Graphics gr){}

}

public class Bird exends Shape{

//画图指令

private void hook_paint(){}

}

7.IOC机制和Default函数

▲ 控制反转 基类的函数可以主动调用子类的函数  。基类与子类之间，控制权是在基类手上透过Hook函数来调用子类 ，通常基类写在先，子类写在后。这种前辈拥有主导权，进而控制后辈。就是IOC（控制反转）

▲默认（Default）行为

 基类的重要功能：提供默认（预设）行为

提供给子类（继承）调用

8.主动和被动型API 

大家都知道 接口是双方接触的地方，也是双方势力和地盘的界线。谁拥有接口的制定权，谁就掌握主动权