第一天
1.什么是类？什么是对象？
1)现实世界是由很多很多对象组成的
基于对象抽出了类
2)对象:真真正正存在的单个的个体
类:代表一类个体(类型、类别)
3)类中可以包含:
3.1)所有对象所共有的属性(静)----变量
3.2)所有对象所共有的行为(动)----方法
4)一个类可以创建多个对象
同一个类创建的多个对象，结构相同，数据不同
5)类是对象的模板，对象是类的具体的实例
2.如何创建类？如何创建对象？
3.引用类型画等号:
1)指向同一个对象
2)对其中一个引用的修改会影响另外一个
eg:房门钥匙
基本类型画等号:
1)赋值
2)对其中一个值的修改不会影响另外一个
eg:身份证复印件
4.null:空，即不指向任何对象
若引用的值为null，则该引用不能再进行任何操作了
若操作则空指针异常(NullPointerException)
补充
1. 1)找对象:一堆小格子
2)抽类:格子类Cell
3)设计类中的成员变量和方法:
4)创建对象:
2. 面向过程是一种以过程为核心的编程思想，即分析出解决问题所需要的步骤，然后使用方法将这些步骤一步一步的实现，使用的时候，在main方法中一个一个依次调用就可以了。
3. 请描述类和对象的关系
参考答案
对象是一个客观存在的实体，是面向对象编程过程中分析与解决问题的出发点与基础。对象的实质就是内存中的一块数据存储区域，其数据结构由定义它的类来决定。
类是用于构建对象的模板，对象通过类的实例化产生，一个类可以创建多个对象，每个对象拥有自己的数据和行为。
3 请描述引用类型和基本类型的区别
参考答案
除8种基本类型之外，用类名（接口、数组）声明的变量称为引用类型变量，简称“引用”。引用的功能在于访问对象。
基本类型变量本身就包含了其实例数据，而引用类型变量中存储的是某个对象在内存中的地址信息。当一个引用类型变量指向该类的对象时，就可以通过这个变量访问对象。
第二天
1.方法的签名:方法名+参数列表
2.方法的重载:
1)同一个类中，方法名称相同，参数列表不同
2)编译器在编译时自动根据方法的签名绑定调用不同的方法
3.构造方法:构造函数、构造器、构建器
1)给成员变量赋初值
2)与类同名，没有返回值类型
3)在创建(new)对象时被自动调用
4)若自己不写构造，则系统默认提供一个无参构造方法
若自己写了构造，则不再默认提供
5)构造方法可以重载
4.this:指代当前对象，哪个对象调指的就是哪个对象
方法中访问成员变量之前，默认有个this.
this用法:
1)this.成员变量名----访问成员变量
2)this.方法名()------调用方法
3)this()-------------调用构造方法
5.引用类型数组
1)
1 Cell[] cells = new Cell[4]; 2 cells[0] = new Cell(2,5); 3 cells[1] = new Cell(3,6); 4 cells[2] = new Cell(4,7); 5 cells[3] = new Cell(5,8);
2)
1 Cell[] cells = new Cell[]{
2 new Cell(2,5),
3 new Cell(3,6),
4 new Cell(4,7),
5 new Cell(5,8)
6 }
3)
1 int[][] arr = new int[3][]; 2 arr[0] = new int[2]; 3 arr[1] = new int[3]; 4 arr[2] = new int[2]; 5 arr[1][0] = 100; //arr中第2个元素中的第1个元素赋值为100
4)
1 int[][] arr = new int[3][4]; //3行4列
2 for(int i=0;i<arr.length;i++){
3 for(int j=0;j<arr[i].length;j++){
4 arr[i][j] = 100;
5 }
6 }
1)找对象:T对象,J,O,I,S,Z,L
2)抽类:T类，J类，L类，O,S,Z,I类
3)设计类中的成员变量和方法:
4)创建对象测试:
知识点补充：
1.一个文件中可以包含多个类
public修饰的类只能有一个
public修饰的类的名字必须与文件名相同
第三天
1.内存管理:理解
1)堆:
1.1)存储所有new出来的对象
1.2)成员变量的生命周期:
创建对象时存在堆中，对象被回收时一并消失
1.3)没有任何引用所指向的对象即为垃圾，
垃圾回收器(GC)不定时查看，看到垃圾则自动回收
1.4)内存泄露:无用的对象没有被及时的回收
建议:若对象不再使用，及时将引用设置为null
2)栈:
2.1)存储正在调用的方法中的所有局部变量
2.2)调用方法时在栈中为该方法分配一块对应的栈帧，
栈帧中存储方法中的局部变量，
方法执行结束时栈帧被消除，局部变量一并消失
2.3)局部变量的生命周期:
方法被调用时存在栈中，方法结束时栈帧被消除时一并消失
3)方法区:
3.1)存储.class字节码文件以及所有方法
3.2)方法只有一份，通过this来区分具体的引用
2.继承:
1)有利于代码的重用(避免代码重复)
2)通过extends实现继承
3)父类/基类:所有子类所共有的特征和行为
子类/派生类/:子类所特有的特征和行为
4)子类继承父类后，具有:
父类共有的+子类特有的
5)一个父类可以有多个子类，
一个子类只能有一个父类---单一继承
6)继承具有传递性
7)java规定:构造子类之前必须先构造父类
子类构造中若没有调用父类构造，则默认添加super()来调用父类的无参构造
若子类构造中调了父类构造，则不再默认提供
super()必须位于子类构造的第一句
3.super:指代当前对象的父类对象
用法:
1)super.成员变量名---访问父类的成员变量
2)super.方法名()-----调用父类的方法
3)super()------------调用父类的构造方法
4.向上造型
1)父类型的引用指向子类的对象
2)能点出来什么，看引用的类型
知识点补充：
1.成员变量:
1)类中，方法外
2)new时存在堆中，对象被回收时一并被清除
3)有默认值
局部变量:
1)方法中
2)方法被调用时存在栈中，调用结束栈帧被清除时一并消失
3)没有默认值
成员变量:有几个对象就有几份(堆)
成员方法:只有一份(方法区)
2. 在JAVA中，有java程序、虚拟机、操作系统三个层次，其中java程序与虚拟机交互，而虚拟机与操作系统交互。编译好的java字节码文件运行在JVM中。
程序中无论代码还是数据，都需要存储在内存中，而java程序所需内存均由JVM进行管理分配，开发者只需关心JVM是如何管理内存的，而无需关注某种操作系统是如何管理内存的，这就保证了java程序的平台无关性。
JVM会将申请的内存从逻辑上划分为三个区域：堆、栈、方法区。这三个区域分别用于存储不同的数据。
3．GC线程会从栈中的引用变量开始跟踪，从而判定哪些内存是正在使用的，若GC无法跟踪到某一块堆内存，那么GC就认为这块内存不再使用了，即为可回收的。但是，java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。
4. 构建T类和J类的父类Tetromino类，将公共的（T类和J类公有的）信息存放在父类中， T类和J类继承Tetromino父类。此时，子类即可以共享父类的数据。这个过程就是泛化的过程。
5.简述JVM垃圾回收机制
垃圾回收机制是Java提供的自动释放内存空间的机制。
垃圾回收器（Garbage Collection，GC）是JVM自带的一个线程，用于回收没有被引用的对象。
6 Java程序是否会出现内存泄露
会出现内存泄漏。一般来说内存泄漏有两种情况。
一是在堆中分配的内存，在没有将其释放掉的时候，就将所有能访问这块内存的方式都删掉；另一种情况则是在内存对象明明已经不需要的时候，还仍然保留着这块内存和它的访问方式（引用）。第一种情况，在Java中已经由于垃圾回收机制的引入，得到了很好的解决。所以，Java中的内存泄漏，主要指的是第二种情况。
7.Foo foo = new Foo();
foo.f();
以上代码的内存实现原理为：
1.Foo类首先被装载到JVM的方法区，其中包括类的信息，包括方法和构造等。
2.在栈内存中分配引用变量foo。
3.在堆内存中按照Foo类型信息分配实例变量内存空间；然后，将栈中引用foo指向foo对象堆内存的首地址。
4.使用引用foo调用方法，根据foo引用的类型Foo调用f方法。
8．当调用子类构造器来初始化子类对象时，父类构造器总会在子类构造器之前执行。子类构造器调用父类构造器分如下几种情况。
A，子类构造器执行体的第一行使用super显式调用父类构造器，系统将根据super调用里传入的实参列表调用父类对应的构造器。
B，子类构造器执行的第一行代码使用this显式调用本类中重载的构造器，系统将根据this调用里传入的实参列表调用本类中的另一个构造器。执行本类中另一个构造器时即会调用父类构造器。
C，子类构造器执行体中既没有super调用，也没有this调用，系统将会在执行子类构造器之前，隐式调用父类无参数的构造器。
第四天
1.方法的重写(override):
1)发生在父子类中，方法名相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象
2.重写与重载的区别:----常见面试题
1)重写:
1.1)父子类中，方法名相同，参数列表相同
1.2)遵循"运行期"绑定，根据对象的类型调用方法
2)重载(overload):
2.1)同一个类中，方法名相同，参数列表不同
2.2)遵循"编译期"绑定，根据引用的类型绑定方法
3.package:
1)避免类的命名冲突
2)类的完全限定名:包名.类名
3)包名建议所有字母小写
import:
1)同包中的类可以直接访问，
不同包中类访问两种方式:
1.1)通过import声明类/引入类
1.2)完全限定名----繁琐
2)语法: import 包名.类名;
4.访问控制修饰符:
1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、子类、同包类
4)默认:什么也不写，本类、同包类
说明:
1)类的访问控制只能是public和默认
2)类中的成员如上4种都可以
5.static:静态的
1)静态变量:
1.1)由static修饰
1.2)是属于类的，存在方法区中，只有一份
1.3)常常通过类名.来访问
1.4)何时用:所有对象的数据都一样时使用
2)静态方法:
2.1)由static修饰
2.2)是属于类的，存在方法区中，只有一份
2.3)常常通过类名.来访问
2.4)静态方法没有隐式this传递，
所以静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
3)静态块:
3.1)由static修饰
3.2)类被加载时自动执行，类只被加载一次，
静态块只执行一次
3.3)何时用:常常用于加载静态资源(图片、音频、视频等)
6.final:最终的
1)修饰变量:变量不能被改变
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承
7.static final-----------自学
补充知识点：
1.实例变量多还是静态变量多?
----------实例变量多
----------静态方法不可能多
2. 静态方法没有隐式的this传递，
没有this意味着没有对象，
实例变量是属于对象，必须通过对象点来访问
所以静态方法中不能直接访问实例成员
3. 成员变量:
1)实例变量:属于对象的，存在堆中，
有几个对象有几份 通过对象点来访问
2)静态变量:属于类的，存在方法区中，
只有一份 通过类名点来访问
4.重写遵守"两同两小一大"原则:----等于时绝对正确
* 1)两同:
* 1.1)方法名相同
* 1.2)参数列表相同
* 2)两小:
* 2.1)子类的返回值类型小于或等于父类的
* 2.1.1)void和基本类型时，必须相同
* 2.1.2)引用类型时，小于或等于父类的
* 2.2)子类抛出的异常小于或等于父类的-----异常之后
* 3)一大:
* 3.1)子类的访问权限大于或等于父类的-----修饰符之后
5.方法重载的要求是“两同一个不同“的原则，
* 1)两同:
* 1.1)方法名相同，
同一类中是指两个方法可以是同一个类中声明的，或者是继承来的，抑或一个是声明的，另一个是继承来的
* 1.2) 同一类
* 2)一不同:参数列表不同
6. 对于类的修饰可以使用public和默认方式。 其中，public修饰的类可以被任何一个类使用，而默认访问控制的类只可以被同一个包中的类使用。
而protected和private访问修饰符是不可以修饰类的，但其可以修饰内部类（后面课程详细介绍）。
7. 关于package和import语句，下面说法错误的是：
A. package 提供了一种命名机制，用于管理类名空间
B. 定义类时，除了定义类的名称以外，必须要指定一个包名
C. import语句用于导入所需要的类
D. 同时使用不同包中相同类名的类，包名不能省略
8. final关键字修饰成员变量，意为初始化后不可改变（对象一旦创建即不可改变），那么该成员变量可以在声明时赋初始值，也可以在构造方法或是静态代码块中初始化。
第五天
1.static final常量:
1)常量必须声明同时初始化
2)不能被改变、通过类名.来访问
3)常量名建议所有字母大写，多个单词用_分隔
4)在编译时被直接替换为具体的值---效率高
2.抽象方法:
1)由abstract修饰
2)只有方法的定义，没有方法的具体实现(连{}都没有)
3.抽象类:
1)由abstract修饰
2)包含抽象方法的类必须是抽象类
若一个类中没有抽象方法，也可以声明为抽象类---我愿意
3)抽象类不能被实例化(new)
4)抽象类是需要被继承的，子类:
4.1)重写父类的所有抽象方法--常用
4.2)也声明为抽象类----不常用
5)抽象类的意义:
5.1)封装子类所共有的数据和行为--子类重用
5.2)为所有子类提供了一种公共的类型--向上造型
5.3)包含抽象方法，为所有子类提供统一的入口
4.接口:
1)是一个标准、规范
只要符合了这个标准、就能干某件事---API
2)由interface定义
3)只能包含常量和抽象方法
4)接口不能被实例化
5)接口是需要被实现/继承的，实现类/子类:
必须重写接口中的所有抽象方法
6)一个类可以实现多个接口，
若又继承又实现时，必须先继承后实现
7)接口可以继承接口
补充知识点
1. 抽象类中可以包含抽象方法和非抽象方法，而接口中的所有方法均为抽象的。
2. 接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作
3. //演示接口的基础语法
1 interface Inter1{
2 public static final int NUM = 250;
3 public abstract void show();
4 double PI = 3.14159; //默认public static final
5 void say(); //默认public abstract
6 }
第六天
正课:
1.多态:多种形态
1)多态的意义:
1.1)同一类型的引用在指向不同的对象时，有不同的实现
行为的多态: cut(),run()
1.2)同一对象被造型为不同的类型时，有不同的功能
对象的多态: 我,水
2)向上造型:
2.1)父类型的引用指向子类的对象
2.2)能造型成的类型:父类、所实现的接口
2.3)能点出来什么，看引用的类型
3)强制类型转换，成功的条件只有两个:
3.1)引用所指向的对象，就是该类型
3.2)引用所指向的对象，实现了该接口
4)只要不符合如上两个条件，
则发生ClassCastException类型转换异常
一般在转换之前先通过instanceof判断:
引用所指向的对象是否是该类型
2.成员内部类:单独应用的几率不太大
1)类中套类，里面的叫内部类Inner，外面的叫外部类Outer
2)内部类通常只服务于外部类，对外不具备可见性
3)通常在外部类中创建内部类的对象
4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有一个隐式的引用指向了创建它的外部类对象
外部类名.this.
3.匿名内部类:
1)想创建一个类(子类)的对象，并且该对象只创建一次，
此时该类不必命名，称之为匿名内部类
2)内部类(成员、匿名)有独立的.class
4.面向对象三大特征:
1)封装:
1.1)类:封装的是对象的特征和行为
1.2)方法:封装的具体的业务逻辑/实现
1.3)访问控制修饰符:封装的是访问的权限
2)继承:
2.1)便于代码的重用
2.2)extends，父:共有的 子:特有的
3)多态:
3.1)意义:
3.1.1)同一类型的引用指向不同对象时，有不同的实现
行为的多态
3.1.2)同一对象被造型为不同的类型的，有不同的功能
对象的多态
3.2)向上造型、强制转换、instanceof
3.3)两种表现形式:
3.3.1)重写
3.3.2)重载
知识点补充:
1.父类大，子类小
类型转换:
1)自动类型转换:从小到大
2)强制类型转换:从大到小
2. 设计原则:
1)将公共的特征和行为抽到父类中
2)若所有子类行为都一样，设计为普通方法
若所有子类行为不一样，设计为抽象方法
3)符合既是也是的关系时，使用接口
3. 继承要符合is a的关系
4. 1)创建了Inter2的一个子类，没有名字
2)为该子类创建了一个对象，名为o3
3).大括号中的为该子类的类体
Inter2 o3 = new Inter2(){};
知识点巩固：
1 1.public class Answer {
2 public static void main(String[] args) {
3 int score = 20;
4 Answer ans= new Answer();
5 ans.add(score);
6 System.out.println(" main： score = " + score);
7 }
8 void add(int score) {
9 System.out.println(" add： score=" + score++);
10 }
11 }
解析：输出add： score=20
main： score =20
原因是score只定义在main函数中，作用域也是main函数，程序调用ans.add函数时，往函数中传给了参数score=20，但是这个函数没有返回值。Main函数中输出的还是变量score=20