JavaSE之"面向对象"

注：要一直站在内存角度看问题。


面向对象与面向过程的区别：
面向对象封装细节，面向过程关注细节，例如开车去新疆。对比自己，以前是面向过程。


一、类概述
类，是抽象。对象是类的实例。

类的成员变量有默认值。
引用：一小块内存指向一大块内存。本质是指针。
String s = new String("HelloWorld");
new创建一块内存。s指向它。有两块内存。new的都在堆中。
s是对象的引用。引用存在于堆中。s是局部变量，本身存在于栈里。

class C{
  int i;
  int j;
  ..main..{
  C c1 = new C();
  C c2 = new C();
  }
}

c1,c2是对象的引用，简称对象。本质是局部变量，在栈中。引用堆中的对应对象。


构造方法
构造方法没有返回值。作用：new就是调用构造方法。
Person{
  int id;
  int age;
  Person(int _id, int _age){
    id = _id;
    age = _age;
  }
}

Person tom = new Person(1, 20);

栈内存：tom在栈内存，_id和_age也是局部变量，也在栈中。
（1）调用构造方法时传入1和20，此时栈内存里_id和_age的值分别变为1和20.
（2）new时，在堆中创建一个对象，并将1和20赋给id和age。
（3）方法调用结束后，栈空间消失，对象（堆中）留了下来。

不写时，使用默认构造方法：空构造方法。


局部变量：
1，基本类型；一块内存，在栈内存。
2，引用类型。两块内存，一块在栈内存，一块在堆内存。

方法调用
1，值传递。

例：
int date = 9;

void change(int i){
  i = 1234;
}

date是局部变量，在栈空间中占一块内存。
函数调用执行时，形参也占一块内存。（copy局部变量的）执行完释放。由于是值传递，并不修改局部变量的值。

2，引用传递。
Test test = new Test();
BirthDate d1 = new BirthDate(7, 7, 1970);
BirthDate d2 = new BirthDate(1, 1, 2000);
test.change2(d1);
test.change3(d2);


public void change2(BirthDate d){
  b = new BirthDate(2, 22, 2004);
}
public void change3(BirthDate d){
  b = setDay(22);
}

在栈内存中：d1,d2
堆内存中：两个对象。d1和d2分别指向他们。

方法调用change2时，在堆内存中生成临时引用变量 d，也指向堆内存中d1指向的对象。
执行b = new BirthDate(2, 22, 2004);后，b又指向堆内存中新开辟的一个对象。
执行完毕，b消失，指向的新对象被垃圾收集器回收。
原来d1指向的内容没有改变。


方法调用change3时，在堆内存中生成临时引用变量 d，也指向堆内存中d2指向的对象。
执行b = setDay(22);后，b修改了指向堆内存中原d2指向对象的值。
执行完毕，b消失，d2指向的内容已经改变。


通过对象调用方法。此时专属一个对象。
静态变量是全局。共享。


形参：
1，传值：复制一份，调完消失。
2，引用：复制一份，也指向对象。调完消失后，也修改了对象的值。



this
指向对象自身。

static
静态：即不属于任何对象，是全局变量。所有对象都可以使用。



二、继承和派生

继承
super()  调用父类构造方法


重载
1，方法重载
2，类 构造方法重载


重写


【类型转换】casting 父类引用指向子类对象
该引用，不能访问子类对象新增的成员（属性和方法）。
例子：
父类——动物Animal
子类——猫Cat，狗Dog
Animal a = new Animal();
a = new Dog();只能看到动物成员。不能看到狗新增加的成员。
想访问，得转型。 Dog d1 = (Dog) a; 此时可以看到狗特有的属性。
a instanceof Animal
if( a instanceof Cat){ Cat cat = (Cat) a; cat.new }
if( a instanceof Dog){ Dog dog = (Dog) a; dog.new }

向上转型（upcasting）子类对象当做基类的对象
向下转型（downcasting）基类的对象当做子类的对象


多态  也叫动态绑定，也叫迟绑定。面向对象 —— 精华，最核心的东西。
与区别是

class Lady{
  private String name;
  private Pet pet;
  Lady(String name, Pet pet){
    this.name = name;
    this.pet = pet;
  }
}
Pet { public void enjoy("叫声。。。")}
Cat { public void enjoy("猫叫声。。。")}  继承Pet
Dog { public void enjoy("狗叫声。。。")}  继承Pet

Cat c = new Cat("catName", "blue");
Dog d = new Dog("dogName", "black");

Lady l1 = new Lady("", c);
Lady l2 = new Lady("", d);
l1.enjoy();
l2.enjoy();
此例即为：动态绑定。
好处：可扩展性。
比类型转型中的instanceof更好用。

三个必要条件
1，有继承
2，有重写方法
3，父类引用指向子类对象
当调父类中被重写的方法时，动态绑定。
总结：说明动态时可以通过举例子的方式。四个对象。一个lady，三个动物。




抽象类
实现多态
其实基类不用实现。直接写成接口。

不能new，只能重写。



final
相当于c++中的Const
变量（普通变量，形参变量）、方法、类
如：String类。


接口
特殊的抽象类
变量：public static final int id = 0;//必须赋初值。
      克服C++多继承。static不属于任何一个对象。final不能修改。
方法：只能是public。

可以用来多继承



[接口：重要]