大纲：
1类的概念：
1.1概念
1.2实例化
1.3类的初始化过程与类的实例化过程的异同？
1.4 java中构造方法和普通方法的区别
1.5 Java 类与类之间的调用
1.6 对象的使用
2面向对象：（三大特征的思想）
封装，继承，多态；
3.类的定义
1）定义与声明
2）引用类型与基本数据类型
4类的构成：
5类的初始化：
6构造方法的重载：
7.实例成员和方法：
8 静态关键字 static 的用法
局部变量，成员变量，全局变量
1概念：
1.1概念
类是一种实体类型的抽象，是一个新的数据类型
从语言层面来看，类就是一个数据结构，类定义数据类型的数据（字段）和行为（方法）。而对象是基于类的具体实体，又是称为类的实例。
1.2实例化
一个对象在可以被使用之前必须要被正确地实例化。
在Java代码中，有很多行为可以引起对象的创建，最为直观的一种就是，使用new关键字来调用一个类的构造函数显式地创建对象，这种方式在Java规范中被称为 : 由执行类实例创建表达式而引起的对象创建。
实例化一个类的对象的过程是一个典型的递归过程。在准备实例化一个类的对象前，首先准备实例化该类的父类，如果该类的父类还有父类，那么准备实例化该类的父类的父类，依次递归直到递归到Object类。
1.3类的初始化过程与类的实例化过程的异同？
类的初始化是指类加载过程中的初始化阶段对类变量按照程序猿的意图进行赋值的过程；
类的实例化是指在类完全加载到内存中后创建对象的过程。
1.4 java中构造方法和普通方法的区别
普通方法，有修饰符修饰的方法，可以有返回值也有的没有返回值。
构造方法，当一个类实例化对象的时候用到的方法就是构造方法，构造方法就是类构造对象时调用的方法，主要用来实例化对象。
构造方法的特殊性：
1.构造方法的名字必须与定义他的类名完全相同，没有返回类型，没有void。
2.类中必定有构造方法，若不写，系统自动添加无参构造方法。接口不允许被实例化，所以接口中没有构造方法。
3.不能被static、final、synchronized、abstract和native修饰。
4.构造方法在初始化对象时自动执行,一般不能显式地直接调用.当同一个类存在多个构造方法时，java编译系统会自动按照初始化时最后面括号的参数个数以及参数类型来自动一一对应。完成构造函数的调用。
5.构造方法分为两种：无参构造方法 有参构造方法
构造方法可以被重载。没有参数的构造方法称为默认构造方法，与一般的方法一样，构造方法可以进行任何活动。
1.5 Java 类与类之间的调用
方法1. 新建一个类。然后在调用类中先进行被调用类实例化，然后通过实例化的对象访问。
方法2.新建一个类，将该类中需要被调用的方法设置为静态（static），加了static后，就可以用类名直接调用。然后在调用类中直接通过类名进行访问。
调用格式为：类名.方法名（参数表）；
注：为什么不能通过对象.来调用构造方法？
打个比方，对象是个人的话，构造方法就是这个人的产生过程：获取资源（构造方法用来实例化对象），按照定义方式生长，而通过对象调用构造方法（构造方法被调用，在调用类中先进行被调用类实例化）大概就是人已经出生了再进行一次出生前的过程了。
1.6 对象的使用
1.6.1 this 关键字的用法：
this 关键字引用类的当前实例，静态成员方法中不能使用 this 关键字。
当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上 this 引用，
this 关键字调用其它类型的构造函数。
调用构造函数应该注意：
1 ） 在构造函数内调用另一个构造函数，调用动作必须置于最起始的位置。
2 ）不能在构造函数以外的任何函数内调用构造函数。
3 ）在一个构造函数内只能调用一个构造函数。
1.6.2 java构造方法的相互调用
在Java中，当给一个类创建了多个构造方法时，有时想在一个构造方法中调用另一个构造方法以减少代码量。这时可以使用this关键字来实现。
通常，当使用this关键字时，它意味着“这个对象”或者“当前对象”，并且它自身产生对当前对象的引用。在一个构造方法中，当给传递给它一个参数列表时，它就有了不同的意义。它将直接的调用能够匹配这个参数列表的构造方法。因此，我们可以直接的调用其它构造方法：
//举例：用this(参数列表)的形式，自动调用对应的构造方法。不可以直接使用类名进行调用。第一个构造方法调用第二个的，第二个的再调用第三个。第三个是最终的实现。这样就能减少代码量。
public class Person {
private String name;
private int age;
//构造方法一
public Person() {
this(null);//String类型是类类型，是引用数据类型，是地址，所以赋值为空
}
//构造方法二
public Person(String n) {
this(n, 12);//调用第三个
}
//构造方法三
public Person(String n, int a) {
this.name = n;
this.age = a;
}
}
2面向对象：（三大特征的思想）
封装，继承，多态；
1）封装机制：把描述对象属性的变量及实现对象功能的方法结合起来，定义一个程序单位，并保证外界不能任意更改内部的属性，不能任意调动内部的方法接口。
2）继承：大大增强了代码的可复用性，提高了软件的开发效率，为程序的修改扩充提供了材料。Java 不支持多继承（菱形继承方式）， Java 不支持继承带来的子类享用多个父类，所以我们引入“接口”概念。
注：菱形继承
https://www.cnblogs.com/sddai/p/6516668.html
3）多态：同一个方法名，根据被调对象的不同，实现了不同的行为。
主要分成
静多态（方法的重载）
动多态（继承，重写，向上造型）
3.类的定义
声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型，Java 使用关键字 class 来声明类。
我们来看以下简单的声明一个类：
定义一个 10 岁名叫张三的学生。
class People{
String name;
int age;
People(String name,int age){
//构造方法不能通过对象.来调用
this.name=name;
this.age=age;
}
void eat(){
System.out.println(name+”在吃饭”);
}
Void sleep(){
Systm.out.println(name+”在睡觉”);
}
Void hitbean(){
System.out.println(name+“在打豆豆”);
}
}
public class Person{
public static void main(String[] args) {
// TODO Auto-generated method stub
People people= new People(“zs”,10);//people 为对象
people.eat();
people.sleep();
}
}
面试题1：
1）定义与声明
定义创建对象并为这个对象分配了内存，声明没有分配内存。
a.声明是向编译器介绍名字–标识符。它告诉编译器“这个函数或变量在某处可找到，它的模样像什么”。
b.定义是说：“在这里建立变量”或“在这里建立函数”。它为名字分配存储空间。无论定义的是函数还是变量，编译器都要为它们在定义点分配存储空间。
对于变量，编译器确定变量的大小，然后在内存中开辟空间来保存其数据，对于函数，编译器会生成代码，这些代码最终也要占用一定的内存。
c. 总之就是：把建立空间的声明称为“定义”，把不需要建立存储空间的称为“声明”。
2）引用类型与基本数据类型
a.基本类型：简单数据类型是不能简化的、内置的数据类型、由编程语言本身定义，它表示了真实的数字、字符和整数。
引用数据类型：Java语言本身不支持C++中的结构（struct）或联合（union）数据类型，它的复合数据类型一般都是通过类或接口进行构造
1 类提供了捆绑数据和方法的方式
2 针对程序外部进行信息隐藏
b.基本类型和引用类型的内存模型本质上是不一样的。
例1：我们分析一下”==“和equals（）的区别。
首先，我定以两个String对象
Stringa=“abc”;
Stringb=“abc”;
然后
if(a==b){
System.out.println(“a==b”);
}else{
System.out.println(“a!=b”);}
程序输出a!=b
原因:a和b的地址是不相同的，a==b比较的是两个变量的地址
例2：定义两个基本类型
int a=4;
int b=4;
if(a= =b){System.out.println(“a==b”);}
else
{System.out.println(“a!=b”);}
输出：a==b
原因：==比较的是两个变量的内容
结论：不论是基本数据类型还是引用类型，他们都会先在栈中分配一块内存，对于基本类型来说，这块区域包含的是基本类型的内容；而对于对象类型来说，这块区域包含的是指向真正内容的指针，真正的内容被手动的分配在堆上。
c.Java中的数据类型分为引用数据类型和基本数据类型。
引用数据类型分3种：类，接口，数组；
基本数据类型又分布尔类型和数值类型；
布尔类型：boolean（逻辑型） trure or false默认是false；
数值类型分定点类型和浮点类型；
定点类型分整数类型和字符型；
https://www.cnblogs.com/dubo-/p/5565677.html
4类的构成：
- 属性（变量）->字段（静态字段，实例字段，常量字段）
- 行为（方法）
5类的初始化：
5.1 通过引用变量进行初始化对象
People p=new People();
p.name=”caocao”;
p.age=10;
5.2 通过默认构造方法进行类的初始化
People(){//通过默认构造函数进行初始化（也可以带有参数）
name=”lisi”;
age=10;
}
5.3 通过普通方法进行类的初始化
void init(){
name=”zhangsan”;
age=10;
}
注：void init():一个初始化方法；
void init(); 是函数声明，类里的init();是调用该函数。
void说明没返回值，init是方法名；
()里面是参数列表，这里没有参数。
5.4 通过静态块进行静态常量成员的初始化
Static {
PI = Math.PI;//只能对未初始化的静态字段进行初始化操作
}
5.5 通过实例代码块进行实例常量成员的初始化操作
{
ID=10；
}
注：java经典实例代码
https://blog.csdn.net/Yaroo/article/details/52195658?locationNum=6
2）限定符的使用（作用域）：
Java 具有封装性：外界不能任意访问对象的属性和方法。
引入访问限定符的使用（作用域）：
package：包访问权限，如果不提供任何访问权限修饰词，则意味着它是包访问权限。
默认访问权限没有任何关键字，但通常是指包访问权限，这个包之外的所有类不可以访问。
public：接口访问权限
private：无法访问
protected：继承访问权限，也提供包访问权限，也就是说，派生类以及相同包内的其他类都可以访问protected成员或方法。
default，同包的的类可见；
这四种修饰符不能用来修饰局部变量，private、protected不能用来修饰类（只有public、sbstract、final可以用来修饰类）。一个java文件中最多只能有一个类是public修饰，并且这个类名必须与文件名保持一致。如果java文件中的所有类都没有用public修饰，那么文件名可以与类名不一致。
https://www.cnblogs.com/coffeerun/p/5728492.html
6构造方法的重载：
方法重载
public void fun(){
System.out.println(“fun()”);
}
public void fun(int a){
System.out.println(“fun(int)”);
}
public void fun(short a){
System.out.println(“fun(short)”);
}
public void fun(int a,int b){
System.out.println(“fun(int,int)”);
}
重载内部也会发生类型的隐式转换。
重载满足的条件：① 函数名相同 ② 参数列表不同 ③ 同一个作用域
7 实例成员变量和方法
1.1 new 实例化类的对象后就可以通过对象. 属性和对象.方法进行类结构的调用
1.2不使用 static 修饰符声明的成员变量和成员方法称为实例成员变量和实例成员方法。类中每一个实例都含有该类所有实例成员变量的一个单独副本。
8 静态关键字 static 的用法
8.1 静态成员方法（只能访问静态成员变量）
静态成员方法访问方式：“类名.静态方法”
8.2 java中不能定义静态的局部变量
JVM，应该知道局部变量是保存在栈中的，而静态变量保存于方法区，局部变量出了方法就被栈回收了，而静态变量不会，所以在局部变量前不能加 static 关键字。
面试题2：
1 局部变量：
1.1 写在函数或者代码块中的变量, 我们称之为局部变量
1.2 作用域: 从定义的那一行开始, 一直到遇到大括号或者return
1.3局部变量可以先定义再初始化, 也可以定义的同时初始化
1.4存储 : 栈 ，存储在栈中的数据有一个特点, 系统会自动给我们释放
2 成员变量：
2.1写在类声明的大括号中的变量, 我们称之为 成员变量(属性, 实例变量)
2.2 成员变量只能通过对象来访问
2.3成员变量不能离开类, 离开类之后就不是成员变量 成员变量不能在定义的同时进行初始化
2.4存储: 堆(当前对象对应的堆的存储空间中) 存储在堆中的数据, 不会被自动释放, 只能程序员手动释放
3全局变量:
3.1写在函数和大括号外部的变量, 我们称之为全局变量
3.2作用域: 从定义的那一行开始, 一直到文件末尾
3.3全局变量可以先定义在初始化, 也可以定义的同时初始化
3.4存储: 静态区
8.3 常量字段
使用关键字 final 作为字段的修饰符，可以声明常量字段。
例：public final int i=10;
注： 1）常量字段必须在声明时进行赋值或者在类的构造方法或者初始化代码中被赋值一次，否则会产生编译错误。
2） 在其他位置上常量字段不能被修改，否则也会产生编译错误。
3） 常量字段可以是静态常量字段或者实例静态常量字段。
4） 常量的名称一般才有大写，多个字之间用下划线连接。常量字段一般声明为 public 、static、final。