1.面向对象和面向过程思想的区别：
面向过程：强调的是功能行为。（强调过程、动作）
面向对象：将功能封装进对象，强调了具备了功能的对象。（强调对象、事物）
面向对象是基于面向过程的。将复杂的事情变简单了。
面向过程-->面向对象：执行者-->指挥者
将过程、功能封装进对象里面。
面向对象三大特征：封装、继承、多态。（找对象，建立对象，使用对象，维护对象的关系。）
老者境界：（万物皆对象！！！）
例：公司招聘程序员：为了提高效率，公司老板从面向过程到面向对象（执行者-->指挥者）
例：去饭店吃饭，服务员具备点菜功能是对象，我们是指挥者
2.事物提取成对象
1.名词提炼法：
例如：
人开门：
人{
开门（门）
{
门.开（）；
}
}
门{
开（）{操作门轴..}
}
3.类（class）和对象的关系：
类是对现实生活中事物的描述。对象就是这类事物，实实在在存在的个体。
描述事物就是描述事物的属性和行为。
属性对应类中的变量，行为对应类中的函数（方法）。
定义类是描述事物定义属性和行为。【属性】和【行为】共同成为类中的成员（成员变量和成员方法）；
（现实生活中对象：张三、李四。
想要描述：这些对象共性内容。对具体的抽象。
描述时：这些对象的共性有：姓名，年龄，性别，学习java时间、功能。）
映射到java中：描述是class中定义的类。具体对象是对应java在堆内存用new建立的实体。
4.成员变量和局部变量的区别：
成员变量作用于整个类中class，局部变量作用在函数（方法）中。
成员变量作用堆内存中因为对象的存在才在内存中存在；局部变量作用于栈内存中。
5.匿名对象：new Car（）.num=5;匿名对象调用属性没意义。调用方法有意义。（方法在方法去中）
当对对象的方法只调用一次时，可以使用匿名对象，这样比较简化；
如果对一个对象进行多成员调用，必须给这个对象起名字。
可以将匿名对象作为实际参数进行传递。
例如：show（new car（））；
public static void show(car c){c.num=3;c.color=4;}//可以简化书写；
6.java 的三大特性（之封装）
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问的方式。
6.1、封装的好处：（1）将外界的变化隔离，使程序具备独立、安全和稳定性。
（2）便于设计者使用，提高代码的复用性
6.2、封装的原则
（1）将不需要对外提供的内容都隐藏起来
2）把实现细节隐藏，提供可以对其进行访问公共的方式
6.3、封装的方式
将某一功能、属性抽离出来，独立写成单独的方法或类
设置访问权限
（1）设置访问权限可以限定该功能或属性可以被特定的访问者访问，保证了程序的安全性和功能的稳定性。
2）Java对类和类中成员都定义了特定的访问修饰符
类：public（公共的） 、default（默认的，不写就默认是它）
类中成员：public、protected、default（默认的）、private
对属性的封装，提供get、set方法访问，赋值private只在私有类中访问。封装不是私有，
私有仅仅是封装的一种表现形式。之所以对外提供访问方式，因为在访问方式中加入逻辑判断等语句。
一个类里面有属性set（void）设置和get返回，那么这个属性是私有的。
注：类的访问修饰符可以不写（默认的），也可以写public（公共的），一个java文件中只能有一个被public修饰的类，且被public修饰的类类名必须要跟文件名一致（包括大小写一致），否则编译会出错，为了方便阅读，类名的命名规范是单词的首字母大写，多个单词组成的类名每个单词的首字母都大写
7.java 中的三种方法
7.1构造方法
构造函数：
和类名一样的方法，叫做构造方法，这个方法的作用，就是初始化出含有不同属性值得实例对象。
public class Student {
String name;// 没有 static 修饰的类属性叫做：成员变量 ，实例变量，实例对象成员变量
int age; //年龄
//构造方法：和类名一样的方法，叫做构造方法，这个方法的作用，就是初始化出含有不同属性值得实例对象。
Student(){//无参构造
System.out.println("我是无参构造，我创建了一个实例对象，但是这个实例对象的成员变量没有值");
}
Student(String varName){//有参构造，只有一个参数的
name= varName;//把构造方法的参数，赋值给它所构造的实例对象的属性
}
Student(String name,int age){//有参构造，有2个参数的
this. name = name;
this.age =age;
}
Student(String varName,int varAge,String intro){//有参构造，有3个参数的
name = varName;
age= varAge;
System.out.println(this.name+intro);//构造方法，传入的参数不一定全部都要赋值给成员变量，也可以进行一些其他的操作
}
//成员方法：没有static 修饰， public 表示成员方法的访问属性，void 表示返回类型
public void lessons( int weekDay){
int i =0;//局部变量，在方法参数列表或者方法的方法体里面定义的变量，都是局部变量，
//方法执行完成之后，就会被自动销毁，应为局部变量在栈区。
switch(weekDay){
case 1:
case 3:
case 5:
System.out.println(this.name+"今天要上上课");
break;
default:
System.out.println(this.name+"今天不上上课");
break;
}
}
public static void main(String[] args) {
Student s1 = new Student();//调用无参构找实例化一个对象
System.out.println("s1 学生的名字："+s1.name);//学生的名字：null
Student s2 = new Student("张三");//调用无参构找实例化一个对象，但是只给成员变量name赋了值
System.out.println("s2 学生的名字："+s2.name);//学生的名字：张三
Student s3 = new Student("张四",21);
System.out.println("s3 学生的名字："+s3.name+",年龄："+s3.age);//学生的名字：张四，年龄：21
Student s4 = new Student("张学友",21," 是一个三好学生");
System.out.println("s4 学生的名字："+s4.name+",年龄："+s4.age);//学生的名字：张四，年龄：21
s1.lessons(1);
s2.lessons(2);
s3.lessons(3);
s4.lessons(4);
Student s5=s4;
if(s5==s4){
System.out.println("s4 和s5是同一个对象");
}else{
System.out.println("s4 和s5不是同一个对象");
}
//new 的作用是开辟一个新的内存空间，去存放S6对象中各种变量的值.
Student s6= new Student("张全蛋");
Student s7= new Student("张全蛋");
if(s7==s6){
System.out.println("s6 和s7是同一个对象");
}else{
System.out.println("s6 和s7不是同一个对象");
}
}
注意：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有啦。
构造函数和一般函数的区别：
构造函数和一般函数写法上、运行上不同，构造函数是在对象一建立就运行。给对象初始化。
而一般方法（set get）是对象调用才执行，是给对象添加对象具备的功能。
一个函数一建立，构造函数只运行一次。而一般方法可以被该函数对象调用多次。构造代码块：
格式：{构造代码块执行语句}；
例如:
{
System.out.println("第一代码块");
}关于构造代码块，以下几点要注意：
1.构造代码块的作用是给对象进行初始化。
2.对象一建立就运行构造代码块了，而且优先于构造函数执行。这里要强调一下，有对象建立，才会运行构造代码块，类不能调用构造代码块的，而且构造代码块与构造函数的执行顺序是前者先于后者执行。
3.构造代码块与构造函数的区别是：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，因为构造函数是可以多个的，运行哪个构造函数就会建立什么样的对象，但无论建立哪个对象，都会先执行相同的构造代码块。也就是说，构造代码块中定义的是不同对象共性的初始化内容。
静态代码块
格式：static{静态代码块执行语句}；
关于静态代码块，要注意的是：
1.它是随着类的加载而执行，只执行一次，并优先于主函数。具体说，静态代码块是由类调用的，当然，建立对象的时候，它也会执行，但是建立多个对象，它也是只会执行一次，并不是说每次建立对象它都要执行，因为它是由类调用的，且只执行一次！就它优先于主函数而执行这点来说，因为主函数也是由类调用的，所以类可以控制着执行的顺序，而实际上，类调用时，先执行静态代码块，然后才执行主函数的。
2.静态代码块其实就是给类初始化的，而构造代码块是给对象初始化的。区分着理解比较容易记牢。
下面结合一个小例子来具体分析三者的用法。
classStaticCode{
int num=9;
StaticCode(){
System.out.println("b");
}
static{
System.out.println("a");
}
{
System.out.println("c");
}
StaticCode(int x){
System.out.println("d");
}
}
public classStaticCodeDemo {
public static voidmain(String[] args){
newStaticCode(1);
}
}
静态代码块是在调用类时立即执行，但此时还没有建立对象。然后执行的是构造代码块。
注意：1 静态代码块不能存在于任何方法体内。2 静态代码块不能直接访问静态实例变量和实例方法，需要通过类的实例对象来访问。
8.局部的变量赋予给成员的用this关键字。（同名）
this的特点：this代表本类【对象】。this代表所在函数所属对象的引用。
哪个对象在调用this所在函数，this就代表那个对象。
this应用：当定义本类中功能，该函数内部调用该函数对象，用this表示这个对象。
9.构造函数之间的调用用this（）；用于区分同名变量的情况。
this语句只能在构造函数第一行。
10.static关键字。是一个修饰符，用于修饰成员（成员变量，成员函数）（在方法区中）
不在堆内存中，对象可以共享。
可以被类名调用。（类名.静态成员）。
static静态的特点：
1.随着类的加载而加载。2.被所用对象共享。3.优先于对象存在。4.可以被类名调用。5.静态变量可以使用get、set方法
特有的数据用成员变量，多个对象共用的数据用静态变量。
11.实例变量和类变量（static）区别
a.类变量随着类的加载存在于方法区中。实例变量随着对象建立存在堆内存中。
b.类变量生命周期长，随着类消失而消失。实例变量随着对象的消失而消失。c.类变量也叫静态变量，也就是在变量前加了static 的变量，主函数是静态的。
d.实例变量也叫对象变量，即没加static 的变量；
12.静态使用注意事项：
a.静态方法只能访问静态成员（属性，方法）。非静态方法既可以访问静态也可以访问非静态。
b.静态方法中不可以定义this.super关键字。（静态优先于对象存在，对象中有this.）
