标签：
二、面向对象 Oriented Object
以类组织代码，以对象来封装数据
面向过程：以方法（函数）组织数据，以线性的思维去解决；当数据量少，无问题；当数据多了，方法多了，以
方法为核心组织代码，累人；扩展性差，不易维护（当多人协同项目时）
C语言结构体，多个变量集合在一块，方便管理；按照这个想法，横向竖向扩散/深入思考，把相近的方法也放在一起，方法反复调用变量，
深度发散，就把方法及变量打包到一块，这种概念在C语言里没有，就起名叫做类 class 【 YY】
以类来组织代码，易于维护，易于扩展
1000个变量 + 1000个方法 -----> 50个类
面向对象优势仅来自软件的复杂性，要是简单的话，就没有必要，用面向过程实现就可以
面向对象的思考方式： 以如何开汽车为例来阐述
面向过程：（事物比较简单，用线性思维去思考解决问题；跟把大象关进冰箱一样）
1.踩离合
2.挂档
3.踩油门，放离合
4.开了
面向对象：多角色，协作完成（思考这些过程要哪些对象）
对象：驾驶员、汽车
驾驶员开汽车
开车细节放在汽车下的方法, car.start(); 来实现
如何造汽车？
面向对象思维：轮胎、座椅、发动机、车架......,将上面造出的东西，组装起来，汽车造出
面向对象思维把握整体，面向过程实现局部细节
面向对象编程(OOP)的本质：以类的方式组织代码，以对象的方式组织（封装）数据
面向对象思维：OOA, OOD
对象：是具体的事物
类：是对对象的抽象，（抽象，抽出象的部分），类是对象的模板。 典型案例：数学 1-10 （1-10个人，1-10个苹果，1-10个等等)
现实的逻辑用代码来实现，静态的数据、动态的行为
===================================================================
JAVA语言中除基本类型之外的变量类型，都称之为引用类型；java对象是通过引用reference（地址）对其操作的
未赋值，默认初始化值
数值型：
--整型：0
--浮点型：0.0
--char型：\u0000
--boolean型：0 false
--字符串 null
属性（成员变量、静态数据）；方法（动态行为），方法隶属于类
成员/实例变量、局部变量
局部变量必须初始化，成员/实例变量未赋值，系统采用默认值初始化
=======================程序执行过程的内存分析（初步分析浅，等待后期改进）====================
栈、堆、方法区
1.栈
自动分配连续的空间，后进先出
存放：局部变量
2.堆
空间不连续
存放：new出来的对象
3.方法区（在堆里划出一部分空间）
存放：类的信息（代码）、static变量、常量池（字符串常量）等
栈帧的概念 ？ ？ //后期补充
JVM在内存中未找到类，会从classpath里加载类，找到class文件，JVM通过类加载器class loader来加载类，加载后，在方法区就有student信息
操作对象，就是操作它的地址，引用类型4个字节
垃圾回收机制(Garbage Collection)；空间分配，new对象；对象空间释放：GC回收没有被引用的对象
===============================构造器===================================
构造器又称构造方法constructor
格式如下：
[修饰符] 类名 （形参列表） {
//n条语句
}
构造方法是一种特殊的方法：
1.通过new来调用
2.定义时无需定义返回值；不能再构造器使用return语句
3.构造器的方法名必须和public class类名一致
4.如果没有定义构造器，编译器会在编译过程中自动构造一个无参构造器；如果已定义，则编辑器不会添加
5.初始化构造该类的对象
1 Car.java: 2 public class Car { 3 int speed; 4 public Car(){ 5 System.out.println("构造一个车"); 6 } 7 } 8 9 TestConstructor.java 10 public class TestConstructor { 11 public static void main(String[] args) { 12 Car c = new Car(); 13 } 14 } 15 16 编译执行结果： 17 构造一个车 18 构造类Car通过new来调用，同时也初始化对象c
============================方法重载 & 构造方法的重载===============================
重载（overload）：最主要是调用时不会产生歧义（编译器不知道调用哪个？）
方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法；调用时，会根据不同的参数表选择对应的方法
两同三不同
--两同：同一个类，同一个方法名
--三不同：参数列表不同（类型、个数、顺序不同）
只有返回值不同是不能构成方法的重载：int a（String str){} / void a(String i){},当调用a(String c),会产生歧义，不知道调用哪个？
只有形参名称不同，也不能构成方法的重载：int a(int b){} / int a(int c){},调用a(int d)会产生歧义
与普通方法一样，构造方法也可以重载；重载条件跟普通方法一致
1 public class TestOverload { 2 public int add(int a, int b){ 3 return a+b; 4 } 5 public static void main(String[] args) { 6 MyMath m = new MyMath(); 7 int result = m.add(4.2,8); 8 System.out.println(result); 9 } 10 } 11 12 class MyMath { 13 int a; 14 int b; 15 16 public MyMath(){ 17 } 18 19 public MyMath(int a){ 20 this.a = a; 21 } 22 23 public MyMath(int b, int a){ 24 this.b = b; 25 this.a = a; 26 } 27 28 public int add(int b, double a){ 29 return (int)(a+b); 30 } 31 32 public int add(double a, int b){ 33 return (int)(a+b); 34 } 35 36 public int add(int a, int b){ 37 return a+b; 38 } 39 40 public int add(int a, int b,int c){ 41 return a+b+c; 42 } 43 44 }
====================================static静态===================================
在类中，用static声明的成员变量称为静态成员变量，或者叫做：类属性，类变量
--它为该类的公用变量，属于类，被该类的所有实例（对象）共享，在类被载入时被显式初始化
--对于该类的所有对象来说，static成员变量只有一份，被该类的所有对象共享
--可以使用“对象.类属性”来调用，不过，一般都是用“类名.类属性”
--static变量置于方法区中
用static声明的方法称为静态方法
--不需要对象，就可以调用（类名.方法名）
--在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员
静态初始化块：
如果希望加载后，对整个类进行初始化操作，可以使用static初始化块；是在类初始化时执行，不是在创建对象时执行
静态初始化块不能访问非static成员
执行顺序：上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到我们的类的静态初始化块为止
静态的方法里不能调用非静态的内容
非静态的方法可以调用静态变量及静态方法
从属于类的方法，不能调用对象内容，对象里没有static
Student.java public class Student { String name; int id; static int ss; public static void printSS(){ System.out.println(ss); } public void study(){ printSS(); System.out.println(name+"在學習"); } public void sayHello(String sname){ System.out.println(name+"向"+sname+"說：你好！"); } } Test.java public class Test { public static void main(String[] args) { Student.ss = 323; //类变量，一般都是用“类名.类属性” Student.printSS(); Student s1 = new Student(); } }
===========================================this=========================================
this用于方法里面，但不能用于static方法里；this隐式参数，jvm调用时会传this参数，方法里可以使用this
普通方法：this总是指向调用该方法的对象
构造方法：this总是指向正要初始化的对象
隐式参数：this super
this();调用其它构造器方法，必须放在第一句
Student.java public class Student { String name; int id; public Student(String name,int id){ this(name); //通过this调用其他构造方法，必须位于第一句！ Constructor call must be the first statement in a constructor this.name = name; this.id = id; } public Student(String name){ this.name = name; } public Student(){ System.out.println("构造一个对象"); } public void setName(String name){ this.name = name; } public void study(){ System.out.println(this.name); this.name= "张三"; System.out.println(name+"在學習"); } public void sayHello(String sname){ System.out.println(name+"向"+sname+"說：你好！"); } } Test.java public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Student s1 = new Student(); s1.name = "李四 "; s1.study(); } } 执行结果： 构造一个对象 李四 张三在學習 构造方法：this总是指向正要初始化的对象 普通方法：this总是指向调用该方法的对象 this的引用地址<--->new对象的引用地址
面向对象三大特征：
===================================继承======================================
OOD角度上看，类是对对象的抽象，继承是某一批类的抽象，从而实现对现实世界更好的建模 //inherited
OOP角度上看，提高代码的复用性
extends “扩展” 子类是对父类的扩展 （class a extends b）
子类继承父类，可以使用父类的全部属性和方法（除父类的构造器外）
java类只有单继承，利于维护（例如：只有一个直属上级，无多个）
java中的多继承，可以通过接口interface实现
如果定义一个类时，没有调用extends，则它的父类是java.lang.Object(根类）
方法的重写： 当从父类继承下来的方法不合适，就需要进行方法的重写；方法的重写跟方法的重载无任何关系
（阅读源代码，需要转换下思维；中文：亚洲、中国、北京、大兴区、街道 | 英文：街道、大兴区、北京、中国、亚洲；
鼠标停留到要查看的类，按住CTRL，跳到类文件里，用来查看源代码；Ctrl + T，查看源码层次）
重写的方法必须跟被重写具有相同的方法名称，参数列表和返回类型
隐式参数： this，super public void run (this,super) {};
this：当前对象的引用（地址）
super：指向父类对象的引用（地址），通过super访问父类的属性或值
构造方法：所有的构造方法，第一句super，调用父类的构造器，除了Object类；如果不加，编译器自动添加
标签：
原文地址：http://www.cnblogs.com/xuliang179/p/5140018.html
