一，基本思想：

1，思想：java认为一切事务皆对象，java通过面向对象的思想和方法思考事物，对象之间通过消息相互作用，现实世界的任何实体都可以归属于某类事务，任何对象都是某一类事物的延伸，如果说传统的面向过程式编程语言是以过程为中心算法为驱动的话，面向对象的编程语言则是以对象为中心，以消息为驱动。

过程式编程语言：程序等于算法加数据。面向对象编程语言则为：程序等于对象加消息。

2，面向对象实例：比如我们程序员和面试官（或者经理），面试官（经理）本身是可以自己敲代码的，他们也是会敲代码的，但是有了程序员以后，他们敲代码的工作完全可以交给程序员来完成，程序员代替了经理或者面试官来敲代码，而面试官面对的不再是枯燥无味的代码了，而是直接将面向了我们，他们不再直接去敲代码而是将任务布置给我们，有我们来完成。这就是面向对象的基本思想。

二，面向对象的基本特点：

1，封装：

封装是面向对象的基本特征之一，是对象和类概念的主要特性。封装就是吧客观事物或者些方法封装成面向对象中的类，该类或者方法对外提供访问的方式。该类可对某些不想让外部知道的信息进行隐藏，外部要操作该类，只需要调用该类即可，不需要关注类中实现细节和方式。这就是封装。

1，封装的表现：

函数就是一个最基本的封装体。

类其实也是一个封装体。

2，封装的好处：

1.提高了代码的复用性。

2.隐藏了实现细节。还要对外提供可以访问的方式。便于调用者的使用。//此既是封装的概念。

3.提高了安全性：如私有变量。private int age。面向对象思想的特征之一。//封装，继承，多态。

3，封装-私有：

private int age//私有仅仅是封装的一种体现形式。private，私有，权限修饰符。

1.对私有变量的访问操作有两个动作两个访问方式：赋值（设置 set），取值（获取 get）；

2.类中不需要对外提供的内容都私有化，包括属性和行为。

3.以后描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。

2，继承：

面向对象的最主要的功能就是继承。该类继承某个类之后，一会从这个父类中继承父亲的所有方法和属性，继承是一种能力，它可以使用现有类的所有功能，并对这些功能进行扩展。

继承概念的实现方式有三类：实现继承，接口继承和可视继承，实现继承是指使用基类的属性和方法而无需额外编码的能力。接口继承是指仅使用属性和方法的名称，但是子类必须提供实现的能力。可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

实例：Employer是一个人,Manager也是一个人，因此这两个类都可以继承Person类。同样他们也都具有了Person类的属性和方法。

体现：

1，成员变量，

1子父类中若定义了一模一样的成员变量num，this.num(访问本类变量)

2如何在子类中访问父类同名变量：super.num（访问父类变量）

super与this的用法很相似：

this：代表的是本类的对象的引用，

super：代表的是父类内存空间，而不是父类对象。不可以直接输出super，但可以直接输出this。

2.成员函数的特点：

字父类中定义了一样的函数，

运行的为结果：为子类在运行。（重写，或覆盖或复写）父类被覆盖了。（overRide）

3.子父类构造函数特点：super

1.子父类中构造函数相同，结果先执行了父类构造函数，然后有执行了子类构造函数//因为子类的所有构造函数中的第一行都有一句隐式语句super（）；默认调用了父类中空参数的构造函数。

2.当父类中没有空参数构造函数时，子类的构造函数必须通过显示的super语句指定要访问的父类的构造函数。

3.子类中所有的构造函数都会去访问父类中默认的空参构造函数。

3，多态：

父类对象的引用指向了自己的子类对象。

好处：提高了程序扩展性，提高代码复用性。

弊端：通过父类引用操作子类对象时，只能使用父类中已有的方法。不能操作子类所特有的方法。

前提：类与类之间必须有关系：可以为继承，也可以为实现，通常都有要重写的方法。

1，向上转型：

Animal a = new dog();//Animal是父类型，new dog()是子对象。父类型的引用指向了子类对象时，这就是让子类对象进行了向上提升（向上转型）。

向上转型好处：提高了扩展性，隐藏了子类型。弊端：不能使用子类型的特有方法了。只有子类型才可以用子类的特有方法。

2，向下转型：

Dog d = (Dog) a;//强制类型转换，向下转型。

无论向上转型，还是向下转型，都是子类对象在做着转换。

3，多态的体现：

1，成员变量的特点：当子父类中出现同名的成员变量时，多态调用成员变量：编译时期参考的是引用型变量所属的类中是否有被调用的成员变量，没有的话则会编译失败。运行时期也是调用引用型变量所属的类中的成员变量。

2，成员函数特点：编译：参考左边，如果引用型变量所属的类中没有被调用的成员函数，则会编译失败，运行的话参考右边对象所属得类。

3，静态函数：静态函数是静态的绑定到类上，不绑定对象，加载时还没有对象，对于静态成员函数，编译和运行都要看左边所属的类型。

总结：对于成员变量和静态函数，编译和运行都看左边，对于成员函数，编译看左边，运行看右边。

三，匿名封装，私有构造函数，成员变量与局部变量：

1，匿名封装：匿名封装：

1.匿名：new Car().run();//这句已执行完就是垃圾，没有东西引用。等同于：Car c = new Car(); c.run();

2.局限：new对象一结束，该对象就是垃圾。

3.作用：当对象对方法进行调用时，而且只调用一次时。可简化成匿名对象书写，需要调用多次时不可以使用匿名对象。

2，私有构造函数：

1，构造函数的特点：

没有返回值类型，因为构造对象，创建完就结束，需要结果。void也无须写，要求别于其他函数。

构造函数名称和类名一致。无具体返回值。

默认对象初始化，构造函数初始化。如果对象一产生就具有某些特点，就需要修改构造函数。 只要定义一个类，该类中就默认有一个空参数的构造函数，是编译时添加到class文件中。

注意：如在类中定义了构造函数，那么默认的空参数构造器函数编译器就不添加了。

原理：没有定义对象的初始化过程，编译器会添加一个默认的初始化过程。如果定义了指定的对象初始化过程，默认的就不添加了。

2，构造函数的细节：

1.一个类中可以有多个构造函数，如：person类 有的一出生就有姓名和年龄。有的既没姓名，又没年龄。多个构造函数的出现时以重载的方式出现的。和类名相同，但参数不同。

2.构造函数中也是有返回值的，有return语句，用于结束初始化动作。

3.构造函数是能被private修饰的。但其他程序无法创建该类对象了。但在本类中可以。

4.构造函数可以调用一般函数或者其他构造函数，初始化是可以涉及到一部分动作，将动作为初始化的一部分。初始化动作必须放在构造函数的第一行。否则易产生冲突，导致编译异常。

5.一个构造函数不能调用两个构造函数。

3，构造函数和一般函数区别：

1.写法不一样，构造函数没有返回值类型。

2.运行上有差别，构造函数对象一创建，就会调用对应的构造函数，一般函数是对象创建后，才会调用所需的一般函数。

3.构造函数中创建了属性，如需修改可以通过set方法完成。

4.构造函数在对象创建时，仅调用一次（初始化动作只做一次，而且先执行）。

4，构造函数之间的互相调用：

1.构造函数是对象初始化时调用的。

2.初始化时，构造函数调用另一个构造函数时，需要使用到this关键字。

3.通过this关键字来记录对象之间的地址，并通过this来明确被初始化的对象。

3，成员变量和局部变量：

1.成员变量与局部变量区别：

1.1定义位置不同：成员变量定义在类中，局部变量在方法中。

1.2在内存中的位置不同：成员变量在堆内存的对象中，局部变量在栈内存方法中。

1.3生命周期不同：成员变量随着对象出现而出现，随着对象消失而消失。局部变量随方法进栈而进栈随方法弹栈而弹栈。

1.4初始化不同：成员变量在堆内存中所以有默认初始值。局部变量无初始值，必须在初始化后才能使用。

B：初始化值区别

成员变量：有默认初始化值

局部变量：没有默认初始化值，要先定义，赋值才能使用。

C：存储位置区别（生命周期不同）

成员变量：堆内存。随着对象的存在而存在，随着对象的消失而消失。

局部变量：栈内存。随着方法的调用而存在，随着方法的消失而消失。

变量使用原则：就近原则

首先在局部方法找，有就使用。

接着在成员方法找，有就使用。

如果成员方法也没有，就报错。

四，基本数据类型：

基本数据类型，也称为简单数据类型，java语言，有8中基本数据类型，按照精度由低到高排序，分别是boolean，byte，short，int，long，float，double，char。

也可将基本数据类型分为四大类型：逻辑类型，boolean，字符类型：char，整数类型：byte，short，int，long。浮点类型：float，double。

把低级别的变量转给级别较高的变量时，系统会自动完成类型转换。

五，常用关键字：

1，this：

1，this关键字：对象调用的方法中都有this引用指向着调用该方法的对象。

2，在构造函数中调用其他构造函数的格式： this（实参列表）；

3，区分同名变量：

this关键字的另一个作用：可以用this标识哪个变量是成员变量，这个表示可以省略不写。但是当局部变量和成员变量同名时，必须用this来标识成员变量。

2,static关键字：

创建对象就是为了产生实例，并进行数据的封装。调用对象时，却没有用到对象中封装的数据，虽然可以编译通过，但会产生堆内存的浪费。

则需要使用静态关键字static：这是一个成员修饰符

静态是随着类的加载就加载了，也是随着类的消失而消失了。 静态优先于对象存在，被对象共享。 静态先存在于内存中无法访问后来的对象中的数据，所以静态无法访问非静态。而且静态中无法书写this，因为这时对象可能不存在，this没有任何指向。

static 关键字修饰静态变量：static修饰成员变量，实现对象的共享，加入静态关键字，避免浪费空间。

静态变量和成员变量的区别：

1，所属范围不同，静态变量所属于类，成员变量所属于对象。静态变量也称为类变量，成员变量也称为实例变量。

2，调用不同：静态变量可以被对象和类调用，（一般都用类名调用），成员变量只能被对象调用。

3，加载时期不同：静态变量随着类的加载而加载，成员变量随着对象的加载而加载。

4，内存存储区域不同，静态变量存储在方法区中，成员变量存储在堆内存中。

public：权限最大。

static：不需要对象，直接给定的类名就可以访问该函数了。

void ：不需要返回值。

main：函数名，该函数名是固定的。

String[] args）：主函数的参数列表：字符串属性类型的参数。

args：arguments：参数。该名称就是一个变量名。约定俗成的参数名称。