1.面向对象概念
面向对象的编程的主要思想是把构成问题的各个事物分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述一个事物在解决问题的过程中经历的步骤和行为。对象作为程序的基本单位，将程序和数据封装其中，以提高程序的重用性，灵活性和可扩展性。类是创建对象的模板，一个类可以创建多个对象。对象是类的实例化。
2.面向对象和面向过程的区别（例java和c）
面向过程：
从名字可以看出它是注重过程的。当解决一个问题的时候，面向过程会把事情拆分成： 一个个函数和数据（用于方法的参数） 。然后按照一定的顺序，执行完这些方法（每个方法看作一个过程），等方法执行完了，事情就搞定了。
其更像流水线上的产品，从原料经历一系列的操作，最终变成成品。
面向对象：
看名字它是注重对象的。当解决一个问题的时候，面向对象会把事物抽象成对象的概念，就是说这个问题里面有哪些对象，然后给对象赋一些属性和方法，然后让每个对象去执行自己的方法，问题得到解决。
可以理解为流水线上执行某一步骤的机器，该机器具有自身独有的功能，能批量的重复这一步骤。当多个这种具有不同功能的机器按流程完成自己的工作，达到所要求的功能。
对比面向过程，是两种不同的处理问题的角度
面向过程更注重事情的每一个步骤及顺序，面向对象更注重事情有哪些参与者（对象）、及各自需要做 什么
举例 ：
面向过程的解决方法：
1、执行加洗衣粉方法；
2、执行加水方法；
3、执行洗衣服方法；
4、执行清洗方法；
5、 执行烘干方法；
衣服像流水线一样经历一系列操作，达到洗衣目的。
面向对象的解决方法：
1、抽象出两个对象：“洗衣机”对象和“人”对象
2、针对对象“洗衣机”加入一些属性和方法：“洗衣服方法”“清洗方法”、“烘干方法”
3、针对对象“人”加入属性和方法：“加洗衣粉方法”、“加水方法”
4、然后两个对象分别执行自身
人.加洗衣粉
人.加水
洗衣机.洗衣服
洗衣机.清洗
洗衣机.烘干
二者执行自己功能，完成要求，两个对象具有一定界限感，洗衣机只执行洗衣工作，人只执行添加工作。便于管理，如后期增加消毒功能，只需要在洗衣机对象添加对应方法。
3.面向对象三大特性
三大基本特性：封装，继承，多态
3.1封装
面向对象编程的核心思想之一就是将数据和对数据的操作封装在一起。通过抽象，即从具体的实例中抽取出共同的性质形成一般的概念，例如类的概念。
在实际生活中，我们每时每刻都与具体的实物在打交道，例如用的钢笔，骑的自行车，乘的公共汽车等。而我们经常见到的卡车、公共汽车、轿车等都会涉及以下几个重要的属性:可乘载的人数、运行速度、发动机的功率、耗油量、自重、轮子数目等，另外，还有几个重要的行为(功能):加速、减速、刹车、转弯等。可以把这些行为称作是它们具有的方法，而属性是它们的状态描述，仅仅用属性或行为不能很好地描述它们。在现实生活中，用这些共有的属性和行为给出一-个概念:机动车类。也就是说，人们经常谈到的机动车类就是从具体的实例中抽取共同的属性和行为形成的一个概念，那么一个 具体的轿车就是机动车类的一个实例，即对象。一个对象将自己的数据和对这些数据的操作合理有效地封装在一起，例如，每辆轿车调用“减速”行为改变的都是自己的运行速度。
封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏（如在声明时选择**「public、protected、包访问权限(默认)、private」**权限从大到小）。
public class test {
public static void main(String[] args) {
Person per=new Person( );
per . name="李四";
per .age=-10;
System. out . println("我的名字是:"+per . name) ;
System . out . println("我的年龄是:"+per.age) ;
}
}
class Person {
String name;
int age;
}
对于年龄不会为负数，但不恰当调用进行了错误的赋值，可以使用 private封装该变量，拒绝外部的调用。
class Person {
String name;
private int age;//设定为私有变量
}
3.2继承
继承体现了一种先进的编程模式。子类可以继承父类的属性和行为，即继承父类所具有的数据和数据上的操作，同时又可以增添子类独有的数据和数据上的操作。例如，“人类”自然继承了“哺乳类”的属性和行为，同时又增添了人类独有的属性和行为。
继承，指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。
继承后的子类可以获得父类的方法和变量（private可以继承无法访问，通过父类的get可以，final无法继承），同时可以声明自己的方法和变量，以减少重复代码的出现。
public class test {
public static void main(String[] args) {
China Li = new China();
Li.setName("李四");//继承的方法
Li.say();
}
}
//父类
class Person {
String name;
public void setName(String name) {//每个人都有名字
this.name=name;
}
}
//子类
class China extends Person {
public void say() {//自己的方法
System.out.println("我来自中国");
System.out.println("我的名字是"+name);
}
}
继承也可以嵌套继承，即b继承a，c继承b
子类也可以对父类的方法进行重写，但方法的访问权限不能小于父类中的访问权限。重写的方法可以是父类方法的子类型（jdk1.5后）。final修饰的方法不能重写。
//重写父类的setName方法
class China extends Person {
public void setName(String name) {
this.name="我的名字是"+name;
}
public void say() {
System.out.println("我来自中国");
System.out.println(name);
}
}
如果子类又声明了和父类继承来同名的变量（类型可以不同），那么继承来的变量会被隐藏。但当子类调用继承来的方法时，操作的一定是继承来的或者隐藏的变量，子类新定义的方法只能操作继承来的和新声明的变量，无法直接操作隐藏的变量，需使用super调用。
关于子类的构造方法
子类并不会继承父类的构造方法，因此当子类创建一个构造方法时，其先调用父类的某个调用方法。使用super调用父类的构造方法时，必须在子类构造方法的头一条语句。
class Student {
int number;String name;
Student() {
}
Student(int number,String name) {
this.number=number;
this.name=name;
System.out.println("我的名字是:"+name+ "学号是:"+number);
}
}
class UniverStudent extends Student {
boolean 婚否;
UniverStudent(int number,String name,boolean b) {
super(number,name);//调用父类构造方法
婚否=b;
System.out.println("婚否="+婚否);
}
}
public class Example5_8 {
public static void main(String args[]) {
UniverStudent zhang=new UniverStudent(9901,"何晓林",false);
}
}
无法复制加载中的内容
abstract类和abstract方法
对于某些功能，没想好怎么实现，或者子类都有不同的想法，可以使用抽象类或者抽象方法，只需要提供类名，返回类型，参数等规范，把具体功能的实现交给子类重写。
- 对于抽象类，里面可以有抽象方法，也可以有非抽象方法，但非抽象类不可以有抽象方法。
- 对于非抽象类继承抽象类，必须重写抽象方法，但抽象类继承抽象类可不重写。
- 虽然抽象类不能用new创建对象，但该对象可以成为其子类的上转型对象，调用重写的方法。
单继承就是一个类只可以继承自一个父类，多继承是指一个类可以同时继承多个父类java中使用的是单继承，也就是一个类有且只能有一个父类，java中可以使用接口实现来实现类似多继承的效果
c++首先引入的多重继承带来了诸如菱形继承一类的问题，而后为了解决这个问题又不得不引入了虚继承这种概念。然而在实际的应用中人们发现继承更多的只被用在两种场合：扩充/改善基类，以及实现多态。对于前者，单继承足以；而对于后者，则真正需要的其实是纯抽象类，即只包含纯虚函数的基类。而对于这一种基类，由于其目的和普通的实例类已经有所不同，因此在java中将其改称为interface，即接口加以明确区分。
因此，java或者c#所谓的不支持多重继承，只是不支持对实例类的多重继承——因为这种继承所带来的一点点代码上的缩减远比不上其引入的麻烦，但是对于用于实现多态的多重继承，即implement interface依然是很好的支持。接口只允许有方法声明而不允许有实现，因而不会出现像C++那样的实现多继承的决议问题；
3.3多态
多态是面向对象编程的又一重要特征。有两种意义的多态。一种多态是操作名称的多态， 即有多个操作具有相同的名字，但这些操作所接收的消息类型必须不同。例如，让一个人执行“求面积”操作时，他可能会问你求什么面积?所谓操作名称的多态性，是指可以向操作传递不同消息，以便让对象根据相应的消息来产生相应的行为。另一种多态是和继承有关的多态，是指同一个操作被不同类型对象调用时可能产生不同的行为。例如，狗和猫都具有哺乳类的行为“喊叫”。但是，狗操作“喊叫”产生的声音是“注....”而猫操作“喊叫”产生的声音是“喵喵.....”。
多态，是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。即父类的某个方法被其子类重写，可以产生自己的功能行为。
上转型对象
将一个子类创建的对象的引用放到父类的对象中，如：
Animal a;
Tiger b = new Tiger();
a = b;//a是b的上转型对象
上转型对象会失去原对象的一些特点，比如说老虎是动物时不关注老虎本身的特点，转而关注其在动物上的特点。
上转型对象具有
- 隐藏的变量
- 继承的变量
- 继承或重写的方法（实例方法重写后，调用重写的方法。静态方法重写后，调用父类方法 ）
即父类本身的内容，没有子类新增的变量和方法。
class 类人猿 {
void crySpeak(String s) {
System.out.println(s);
}
}
class People extends 类人猿 {
void computer(int a,int b) {
int c=a*b;
System.out.println(c);
}
void crySpeak(String s) {
System.out.println("***"+s+"***");
}
}
public class Example5_10 {
public static void main(String args[]) {
类人猿 monkey;
People geng = new People();
monkey = geng ; //monkey是People对象geng的上转型对象
monkey.crySpeak("I love this game");//等同于geng.crySpeak("I love this game");
People people=(People)monkey; //把上转型对象强制转化为子类的对象
people.computer(10,10);
}
}
多态即有多个子类重写父类方法后，通过上转型对象表现出多种形态
class 动物 {
void cry() {
}
}
class 狗 extends 动物 {
void cry() {//重写父类方法
System.out.println("汪汪.....");
}
}
class 猫 extends 动物 {
void cry() {//重写父类方法
System.out.println("喵喵.....");
}
}
public class Example5_11 {
public static void main(String args[]) {
动物 animal;
animal = new 狗();
animal.cry();
animal=new 猫();
animal.cry();//animal产生狗和猫的两种行为
}
}
