首先，面向对象是一种思想。
有一种面向过程的思想，面向对象就是基于面向过程的。
举个例子：把大象放进冰箱中。
面向过程:
用我们程序模拟 (java是纯面向对象语言)
class Demo{
public static void main(String[] args){
/*
这几个动作相当于功能
既然是功能就用方法封装
*/
//先打开冰箱门
open();
//把大象装进去
in();
//关闭冰箱门
close();
}
public static void open(){
System.out.println("打开冰箱门!");
}
public static void in(){
System.out.println("把大象装进去!");
}
public static void close(){
System.out.println("关闭冰箱门!");
}
}
面向对象思想怎么做这件事:
A:要有哪些类?
B:类里面有什么功能?
C:类与类之间有哪些关系呢?
A:要有哪些类?
名词提取法;
大象:
冰箱:
Demo:程序的入口
B:类里面有什么功能;
大象:
装进冰箱
冰箱:
开门
关门
Demo:程序的入口 main
C: 通过Demo去调用大象和冰箱的功能
class 大象{
public static void in(){
System.out.println("把大象装进去!");
}
}
class 冰箱{
public static void open(){
System.out.println("打开冰箱门!");
}
public static void close(){
System.out.println("关闭冰箱门!");
}
}
class Demo{
public static void main(String[] args){
通过冰箱去做打开冰箱门的操作;
通过大象去做进入冰箱的操作;
通过冰箱去做关闭冰箱门的操作;
}
}
这是伪代码，不过显而易见，面向对象更容易接受，也不繁琐。
面向对象(开发,设计和特征)(了解)
A:面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。
B:面向对象设计
其实就是在管理和维护对象之间的关系。
C:面向对象特征：封装(encapsulation)，继承(inheritance)，多态(polymorphism)。
1、 封装：
该公开的公开，该私有的私有；
类的属性一般私有；类的方法：该公开的公开，该私有的私有；
类，封装了数据和方法；方法，封装了实现的过程，接口是参数和返回值；
数据原型类：又叫实体类
1）get/set 方法；对某一个属性只提供get不提供set方法，就是只读的，在类的外部不能修改；
2）提供统一的参数检查，在set上给与检查，判断合法性和安全性；
将属性都私有，并且提供set/get 方法，做成了通用的组件，叫JavaBean;
2、 继承：
任何父类适用的地方，子类一定适用；单纯的代码复用不需要继承
extends: 继承，实际上是对父类的扩展；
生成对象的过程是怎么样的？
1）分配对象空间；
2）给属性赋初值；boolean:false;数值类型：0或0.0; 对象类型：null;
3）调用构造方法；
定理：JVM：上帝；构造学生，先构造一个人；
1）任何子类的构造方法都会调用父类的构造方法；
2）任何类都有构造方法，如果程序员自己不定义则系统会加上一个默认的无参空实现的构造方法；如果定义了，则系统不会加；
3）任何子类的构造方法的第一行一定是super(…)或this(…);如果程序员不这么写，则系统会默认加上super();
自己写this()就不会加super();但this()调用的构造方法一定 会调用父类的构造方法；
This(…); //表示调用本类的其它构造方法，只能出现在构造法的第一行；其它位置都是不合法的；
public Animal(String name,int age,int legs){
//super();//系统默认加一个super();
this.name=name;
this.age=age;
this.legs=legs;
}
public Animal(String name,int age){
// this.name=name;
// this.age=age;
// this.legs=4;
this(name,age,4);//调用本类的其它构造方法；只能出现在构造方法的第一个有效行；系统不会在这里加一个super();
//但是this(name,age,4);会调用3个参数的构造方法，这个构造方法会默认调用父类的构造方法；
}
Super(…);//调用父类的构造方法，也是只能出现在构造方法的第一行；根据参数类型来确定调用父类的哪个构造方法；
Super();//默认调用父类的无参的构造方法；
即使把父类的私有属性继承下来了，但是还是不能直接访问，必须用getName();
如果在子类中定义一个和父类相同的属性name,那么在子类中用 super.getName()来和子类的name 区分；
总结：
Super.xxx ;//在子类中有和父类同名的属性时；
this.xxx //方法中有局部变量和成员变量命名冲突
Super(xxx);//调用父类的构造方法，只能出现在构造方法的第一行；
this(xxx);//调用本类的其它构造方法，也是只能出现在构造方法的第一行，不能和this同时出现；
如果在子类中定义和父类同名的属性是不推荐的，一般不要这么写；也没有意义；也不符合规范的；
方法是经常覆盖的；
方法的覆盖：
1）发生在父子类中；
2）同名、同参、同返回值
3）访问权限跟父类相同或更宽；不能比父类更封闭；
4）子类方法抛出异常的类型不能比父类方法更宽泛；
Move()//父类; move(int)//子类； 不叫覆盖，也可以叫重载；
3.多态：
类中多个方法的重载叫多态，父子类中方法的覆盖也叫多态。
因此多态有两种体现：一个是方法的重装，一个是方法的覆盖。
多态有方法的多态和对象的多态（一个对象多种形态）。
多态的前提：将子类对象当作父类对象来看，
体现在代码上就是Animal a=new Bird(....);
所有的多态可以归结为两个定理：
1.可以把子类对象当作父类对象来看，一旦这样做了，就只能去调用父类中原有定义的属性和方法，
也就是子类中扩展的方法或属性就不能调用了。
2.当我们把子类对象当作父类对象来看的时候，如果子类覆盖了父类中的方法，在调用的时候实际调用的是子类覆盖后的方法。
Animal a=new Bird();前面的引用a的类型叫做编译时类型（主观认为），
后面的bird 类型叫做运行时类型（客观存在）。
强制类型转换的前提是你的运行时类型本来就是你要强制转换成的类型。
要想知道某个对象是否是某一个类的实例： instanceof,他的左边是个对象名，右边是类名或者是接口名，
如果这个对象是右边的类的实例，返回真，否则返回假。 这个方法会做自动类型兼容。