Java面向对象

按照东西的特征和自然组织形式, 进行软件开发过程的
  组织, 是一个开发过程的方法论. 
学习面向对象: 学习如何用OO语法描述事物的特征和
  自然组织形式. 

学习面向对象思维的前提是朴素的哲学逻辑.
如: 多态, 抽象概念的具体实现是多态的,
   如:美女是多态的!

对象(Object)->东西, 啥都是东西.

类(Class)
  类是用来描述一个领域模型中的具体概念(名词)的. 
  领域模型: 一个应用软件业务范畴, 也叫业务模型.
  属性: 描述具体概念的特征.

案例:
  <图书馆管理系统>中的概念: 书 Book
  书的特征: 书号, 书名, 编号, 作者, 价格...

Java中的类语法
  修饰词 class 类名{
  修饰词 类型 属性;
  }
  
  public class Book{
  int id;
  String name;
  String[] authors;
  String isbn;
  double price;
  }

对象（Object）概念的具体实例，对象是类的具体实例！
  《山楂树之恋》是一本书，
  《和空姐同居的日子》是一本书，

引用：是指向具体对象的句柄，相当于自然语言的代词。
   
   请给我《山楂树之恋》这本书，这本书很感人。
   对不起，书卖完了！
   
   代词本身不是对象，代词引用了一个具体对象。
   在特殊情况下代词可能指空。
   经常简单的叙述事物时候，不严格区别代词与对象。
   
Java 中的引用和对象
  Book book = new Book();
  //book 引用变量，具体引用一个书的实例。
  book.name = "月子";
  book.authors = new String[]{"白云","黑土"};
  book = null;//book引用null
   
引用是null时候,访问属性或方法时候会出现: 
  空指针异常 java.lang.NullPointerException
  
案例:
  平面绘图坐标系中的一个点(Point),定义合理的属性
  坐标是int类型.
   O+-----------------------------> X
    |
    |
    |
    |
    |          . p(x,y)
    |
    |
    |
    |
    
    Y
   
构造器(构造方法) 
  用来描述对象的创建过程的.
  如: 月饼实例的创建, 使用面和馅创建.
              制作(构造器)
  月饼模子(类)  -----> 月饼(对象)
              原料(构建参数)
   
  点类型   -------->  原点 
           (0,0)
  
Java中的构造器: 声明在类内部, 方法名与类名一致
  的方法叫构造方法, 构造方法不能声明返回值类型.
  构造方法可以包含参数, 参数一般是创建对象实例
  必须依赖的条件(前提条件).




new运算: 创建对象实例
  1 根据类的属性在堆中分配对象空间.
  2 根据参数类型调用构造器.
  3 new运算返回对象的引用地址.
对象的创建过程
  1 根据类的属性在堆中分配对象空间,并且自动初始化.
  2 根据参数类型调用构造器.




this 是对当前对象的引用, 是当前对象本身.
  可以使用this明确的访问当前对象的属性或者方法
  类似于"我".
this() 是调用本类的其他构造器, 可以使用构造器的
  重用, 简化代码的实现. 
  * this() 必须写在构造器的第一行!




构造方法经常会重载
案例: Book.java
   方法签名 = 方法名+参数类型列表
   方法重载:a 方法名一样 b 方法参数不一样
     也可以说: 方法名一样, 方法签名不同的方法
   
默认构造器
  案例: ConstructorDemo.java
  1 如果类没有声明任何构造器,Javac自动提供一个
  默认构造器, 无参数默认构造器
  2 如果提供构造器声明, Javac将不再提供默认构
  造器.   
    
对象的方法, 表示对象的功能, 依赖于对象存在.
  案例: Point.java
  如: p1.distance() 和 p2.distance()
  方法是动作,是功能,一般用动词声明.  
  方法也经常重载, 重载:方法名一样, 参数不一样
  重载体现了, 功能的多态.
  重载的方法经常互相重用.
  
  
java方法参数的传递规则: 基于值的传递, 是变量值的
  复制, 基本类型就是其中值的复制, 引用类型是引用
  值(地址)的复制.
  案例: ParamaterDemo.java
  * 变量的值: a 基本类型的值是其本身,
           b 引用变量的值是一个地址值, 
             是被引用对象的首地址.
  为了避免引用参数传递的副作用, 建议一切结果使用
  返回值带回. 




数组对象
  int[] ary = new int[10];
  int[] ary1 = ary;
  //数组的复制
  int[] ary2 = new int[10];
  for(int i=0; i<ary.length; i++){
  ary2[i] = ary[i];
  }
  //ary2 是 ary 一个副本
  //java 提供了现成的复制方法:
  int[] ary3 = new int[10];
  System.arraycopy(ary, 0, ary3, 0, 10);
  //Java6 以后提供了:
  int[] ary4 = Arrays.copyOf(ary, 11);
  
元素是对象数组
  String[] authors = new String[5];
  Book[] books = new Book[]{
    new Book(1, "日子"), 
    new Book(2, "空姐")};
集体案例：
  package day08;




public class Point {
  int x;
  int y;
  public Point(int x, int y){
    System.out.println(
        "调用构造器:this.x="+this.x+",this.y=" + this.y );
    this.x = x;
    this.y = y;
  }
  // 计算当前点到原点的距离
  public double distance(){
    return Math.sqrt(this.x * this.x + 
        this.y*this.y);
  }
//计算当前点(this)到另外一点(other)的距离
  //计算当前点(this)到另外一点(other)坐标的距离
  public double distance(Point other){
//    return Math.sqrt((this.x-other.x)*(this.x-other.x)
//        +(this.y-other.y)*(this.y-other.y));
    return distance(other.x, other.y);
  }
  //计算当前点(this)到另外"坐标"的距离
  public double distance(int x, int y){
    return Math.sqrt((this.x-x)*(this.x-x)
        +(this.y-y)*(this.y-y));
  }
}
//Point o = new Point(1,2);
——————————————————————————————————
package day08;




public class ParamaterDemo {
  public static void main(String[] args) {
    Koo koo = new Koo();
    int a = 1;
    update(a);
    update(koo);
    System.out.println("a="+a+",koo.a="+koo.a);//1,2
    int b = update2(a);
    int c = update2(koo);
    System.out.println("b="+b+",c="+c);//2,3
    
  }
  static void update(int a){
    a++;
  }
  static void update(Koo koo){
    koo.a++;
  }
  
  static int update2(int a){
    a++;
    return a;
  }
  static int update2(Koo koo){
    koo.a++;
    return koo.a;
  }
}
class Koo{
  int a=1;
}