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 = newCell[]{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

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 interfaceInter1{2 public static final int NUM = 250;3 public abstract voidshow();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 classAnswer {2 public static voidmain(String[] args) {3 int score = 20;4 Answer ans= newAnswer();5 ans.add(score);6 System.out.println(" main： score = " +score);7 }8 void add(intscore) {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