一、背景
Java： 1990年由 sun公司 James Gosling 等开发的Oak发展而来，后oracle收购，维护
1、命名（语义化并遵守相应规范
多个单词合成一个识别字时，
帕斯卡原则：每个单词首字母大写 eg：FirstName、LastName （大驼峰原则）
驼峰原则：除第一个单词之外，其他单词首字母大写 eg：myStudentCount（小驼峰原则）
标识符命名规则： // 标识符：给类，接口，方法或者变量等等起的名字
字母、数字、下划线、$组成（不能是保留字，不能以数字开头，并且区分大小写）
1、 项目名全部小写
2、 包名全部小写 // 倒置的域名
3、 类名（驼峰原则）
4、 变量名、方法名(驼峰原则)
5、 常量名(全大写，下划线连接) eg：public static final String GAME_COLOR=”RED”;
注：命名语义化（方法用动词，其他用名词，通过名字基本确定要说什么。eg：eat()吃的方法 Appple表示苹果类 ）
2、注释
单行： // 注释文字
多行： /* 注释文字 */
文档注释： /** 注释文字 */ 可生成说明文档
注：功能说明的注释用文档注释（可以生成说明文档）eg：类说明，成员变量成员方法的说明
3、常用编辑快捷键
Ctrl+A 全选
Ctrl+C 复制
Ctrl+V 粘贴
Ctrl+X 剪切
Ctrl+Z 撤销
Ctrl+S 保存
4、DOS命令
d: 回车 盘符切换
dir(directory):列出当前目录下的文件以及文件夹
md (make directory) : 创建目录
rd (remove directory): 删除目录
cd (change directory)改变指定目录(进入指定目录)
cd.. : 退回到上一级目录
cd\: 退回到根目录
del (delete): 删除文件,删除一堆后缀名一样的文件*.txt
exit : 退出dos命令行
cls : (clear screen)清屏
5、环境配置
JAVA_HOME: "D:\Program Files\Java\jdk1.8.0_91" // JDK路径
path： "%Java_Home%\bin;%Java_Home%\jre\bin;" // 到bin，jdk和jdk下jre的bin
classpath： ".;%Java_Home%\bin;%Java_Home%\lib\dt.jar;%Java_Home%\lib\tools.jar"
注：配置环境变量的目的是为了让java文件和class文件在任意目录下都能正常运行
6、Class文件反解可以使用软件jd-gui
7、关键字
(1)关键字:被Java赋予特定含义的单词
(2)特点:全部小写
注： goto和const作是保留字存但不是关键字，不能使用（保留字：高级程序曾定义过的字）
8、解释与编译
解释执行：解释的同时执行程序，不生成目标程序 eg:java
编译执行：先编译产生机器语言的目标程序，然后执行程序 eg:C
注：java程序的运行：java代码生成中间二进制字节码.class文件；类加载器加载到虚拟机(在虚拟机中以class对象的形式存在)
9、JVM管理的内存区域：
9.1. 程序计数器（Program Counter Register）：指示当前线程所执行的字节码执行到了第几行，线程私有（一个线程就有一个程序计数器）
9.2. 栈（Statck）：存放局部变量 eg：基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中
（每个线程对应着一个虚拟机栈，一个线程的每个方法在执行的同时，都会创建一个栈帧，栈帧中存储：
局部变量表、操作站、动态链接、方法出口等，当方法被调用时，栈帧在JVM栈中入栈，当方法执行完成时，栈帧出栈。
，因此虚拟机栈也是线程私有的。）
9.3. 堆（heap）：JVM内存中比重最大的一块，所有线程共享，存储对象的实例(new产生)
9.4. 方法区（Method Area）:也叫静态区，存放所有的class和static定义的静态成员
（各个线程共享的区域,用于存储已经被虚拟机加载的类信息、final常量、静态变量、编译器即时编译的代码等，常量池是方法区的一部分）
10、通过生命周期分析变量的位置：
成员变量：创建对象就产生，对象销毁销毁 故与对象一起 在堆里
局部变量：方法调用产生，跳出方法域销毁，在方法对应的栈帧上
11、GC 垃圾收集（Garbage collection）：
jvm上的垃圾回收主要针对堆区（线程共享），
程序计数器、栈（虚拟机栈、本地方法栈）随线程而生灭，方法结束或者线程结束时，内存就回收了，没有过多的垃圾回收问题（线程私有）
12 、 并发：用户线程与GC线程同时执行；
并行收集：多个GC线程并行工作，但此时用户线程是暂停的；
13、缩写：
jvm Java虚拟机
jdk Java开发工具包（Java Developer's Kit）
jre Java运行环境（Java Runtime Environment）
GC 垃圾收集（Garbage collection）
二、 基础知识
常量：值不发生改变的量
字面值常量：
A:字符串常量 用""括起来的内容。举例："helloworld"
B:整数常量 举例:1,200
C:小数常量 举例:12.5
D:字符常量 用''括起来的内容。举例：'a','A','0'
E:布尔常量 比较特殊，只有两个值。举例：true,false
F:空常量 null(数组部分讲)
整数常量的表现形式：// x进制表示逢x进1
A:二进制
由0,1组成。以0b开头
B:八进制
由0,1,2,3,4,5,6,7组成。以0开头
C:十进制
由0,1,2,3,4,5,6,7,8,9组成。默认是十进制。
D:十六进制
由0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F组成。以0x开头。
注意：字母不区分大小写。
变量
(1)变量：值会发生改变的量。
(2)定义格式：
A:数据类型 变量名 = 初始化值;
B:数据类型 变量名;
变量名 = 初始化值;
数据类型
(1)数据类型分类
A:基本类型：4类8种
B:引用类型：类，接口，数组
(2)基本类型-
A:整数 占用的内存空间
byte 1 -2^7 ~ 2^7-1， 即-128 ~ 127 末尾加B
short 2 -2^15 ~ 2^15-1， 即-32768 ~ 32767
int 4 -2^31 ~ 2^31-1， 即-2147483648 ~ 2147483647。 （21亿 ，强转超过范围的数据，循环）
long 8 -2^63 ~ 2^63-1， 末尾加L。（也可以不加L）
B:浮点数
float 4 末尾加F。（也可以不加F）
double 8 （默认）
C:字符
char 2 // 汉字 、字母 都是用unicode码表示的，都是char类型
D:布尔
boolean 1
无符号整数会用全部为来存储，有符号的整数，最高位当做符号位 ，其余为表示数值。0正1负
类型转换
注意：boolean类型不参与。
隐式转换：从小到大（参加计算就会发生隐式的类型转换）
byte,short,char --> int --> long --> float --> double
强制转换：从大到小
一般不建议这样做，因为可能有精度的损失。
格式：
目标数据类型 变量名 = (目标数据类型)(被转换的数据);
注：
1、int范围比float 和double都大，隐式转换可能会精度丢失】
2、（byte in = 5; s+=5; 这种形式s计算产生的int会被强制转换为byte）
算术运算符
(1)+,-,*,/,%,++,--
(2)+:
正号
加法
字符串连接符
(3)%和/的区别
%：余数
/：商
整数相除，结果是整数。想得到小数，可以乘以或者除以1.0
%的结果的符号和前面的那个数一致。
(4)++,--
A:单独使用
放在数据的前面和后面效果一样。
B:参与操作使用
放在数据的前面，先数据变化，再参与运算。
放在数据的后面，先参与运算，再数据变化。
C:++,--的练习题。
赋值运算符
(1)=,+=,-=,*=,/=,%=,...
(2)基本用法
int a = 10;
把10赋值给int类型的变量a。
(3)复合用法
int a = 10;
a += 20;
值等价于：a = a + 20;
把左边和右边的结果赋值给左边，并强制转换为左边的类型。
即：
short s = 1; s = s + 1; 错
short s = 1, s +=1; 对
关系运算符
(1)==,!=,>,>=,<,<=
(2)注意：
A:无论表达式简单还是复杂，结果肯定是boolean类型
B:千万不要把"=="写成"="
逻辑运算符
(1)&,|,^,!,&&,||
(2)单用法
&:有false则false
|:有true则true
^:异或 （同真异假：同或 同假异真：异或）
!:偶数个，值不变；奇数个，值相反。
(3)双用法:
&&,||和&,|的区别
&&具有短路效果，左边为false，右边不执行。
||具有短路效果，左边为true，右边不执行。
位运算符
(1)&,|,^,~,>>,>>>,<<
做位运算，需要把数据转换为二进制。
(2)^的特点：
针对同一个数据异或两次，值不变。
请用最有效率的方式计算2乘以8的值：2*8 2<<3（小数点位置不变左移3位）
三元运算符
(1)格式：
关系表达式?表达式1:表达式2;
(2)执行流程：
A:计算关系表达式的值
B:如果是true，表达式1就是结果
如果是false，表达式2就是结果
Scanner类 // 键盘录入数据
(1)导包： import java.util.Scanner;
(2)创建键盘录入对象：Scanner sc = new Scanner(System.in); //system.in标准输入流 hashnext() / hashnextInt()
(3)获取数据 int i = sc.nextInt();
if语句
(1)三种格式
A:格式1
if(关系表达式) {
语句体;
}
执行流程：
a:计算关系表达式的值
b:如果是true，就执行语句体
如果是false，就不执行语句体
c:继续向下执行
B:格式2
if(关系表达式) {
语句体1;
}else {
语句体2;
}
执行流程：
a:计算关系表达式的值
b:如果是true，就执行语句体1
如果是false，就执行语句体2
c:继续向下执行
C:格式3
if(关系表达式1) {
语句体1;
}else if(关系表达式2) {
语句体2;
}else if(关系表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
执行流程：
a:计算关系表达式1的值
b:如果是true，就执行语句体1
如果是false，就计算关系表达式2的值
c:如果是true，就执行语句体2
如果是false，就计算关系表达式3的值
...
switch语句
(1)格式：
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
...
default:
语句体n+1;
break;
}
注：表达式的取值
byte,short,int,char // 计算转换为int的4个基本数据类型
JDK5以后可以是枚举
JDK7以后可以是String
for循环语句
for语句基本格式
for(初始条件表达式;判断条件表达式;控制条件表达式) {
循环体；
}
for循环的执行流程
A:执行初始条件表达式
B:判断控制变量的值
如果判断为true，则执行下一步；为false，则结束
C:执行循环体
D:执行控制条件表达式，控制变量
E:再回到B
while循环
while语句基本格式
while(判断条件表达式) {
语句体；
}
do...while循环
do...while语句基本格式
do {
语句体
}while(判断条件表达式)
注：
A:三种循环的比较
for循环和while循环中的循环体可以一次不执行，do...while循环中循环体
至少执行一次
B:三种循环的使用
a:可以相互等价转换，相互改写
b:当循环变量需要保留下来供以后计算，则使用while循环在循环体前面定义
控制变量；否则建议优先使用for循环，提高程序运行效率；其次是while循
环，最后是do...while循环
C:for循环适用于知道一定范围，while循环更常用于循环次数不一定
break 跳出循环
continue 进行下次循环
两个关键字都可以跳转标记
一维数组
(1)数组:存储同一种数据类型的多个元素的集合
每个元素都有编号，从0开始。
最大编号是数组的长度-1
(2)数组的格式：
A:数据类型[] 数组名;
B:数据类型 数组名[];
(3)数组的初始化：
A:动态初始化 只给长度，不给元素
int[] arr = new int[3];
B:静态初始化 不给长度，给元素
int[] arr = new int[]{1,2,3};
简化版：int[] arr = {1,2,3};
(4)两个常见小问题
A:数组越界
B:空指针异常
(5)数组常见操作 获取数组长度：数组名.length
二维数组
(1)二维数组：元素是一维数组的数组。
(2)格式：
A:数据类型[][] 变量名 = new 数据类型[m][n];
B:数据类型[][] 变量名 = new 数据类型[m][];
C:数据类型[][] 变量名 = new 数据类型[][]{{元素...},{元素...},{元素...}};
数据类型[][] 变量名 = {{元素...},{元素...},{元素...}};
类与对象
类：具有共性的事物的抽象
属性：外在特征
行为：内在行为
对象：是该类事物的具体个体。
类的组成
(1)成员变量
定义在类中，方法外，有默认值
(2)成员方法
eg： class Student {
String name;
int age;
public void study() {}
}
类的使用
(1)创建对象
格式：类名 对象名 = new 类名();
(2)使用成员
成员变量：对象名.变量名;
成员方法：对象名.方法名(...);
成员变量和局部变量的区别
(1)在类中的位置不同
A:成员变量 类中，方法外
B:局部变量 方法的形式参数，或者方法体中
(2)在内存中的位置不同
A:成员变量 在堆中
B:局部变量 在栈中
(3)生命周期不同
A:成员变量 随着对象的存在而存在，随着对象的消失而消失
B:局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
(4)初始化值不同
A:成员变量 有默认初始化值
B:局部变量 没有默认值，必须先声明，赋值，最后才能使用
值传递：
(1)基本类型 基本类型作为形式参数，传递的是该基本类型的值 --值传递
(2)引用类型 引用类型作为形式参数，传递的是该引用类型的值（是指向其对应对象的地址） --地址传递
匿名对象
(1)匿名对象：没有名字的对象。是对象的简化书写方式。
(2)使用场景
A:调用方法，仅仅只调用一次
B:作为实际参数传递
封装
(1)隐藏实现细节，提供公共的访问方式
(2)好处：
A:隐藏实现细节，提供公共的访问方式
B:提高了代码的复用性
C:提高了代码的安全性
(3)使用原则
A:把成员变量隐藏
B:给出该成员变量对应的公共访问方式
this关键字
(1)this：代表本类的对象
(2)应用场景：
解决了局部变量隐藏成员变量的问题。
其他用法和super一起讲。
构造方法
(1)作用：创建对象
(2)特点：
A:方法名和类名相同
B:没有返回值类型
C:没有返回值
(3)注意事项
A:如果我们没写构造方法，系统将默认给出无参构造方法
B:如果我们写了构造方法，系统将不再给出默认无参构造方法
注：无参的构造方法，可以没有，但是开发过程中一定要写，spring框架ioc通过无参数构造方法创建对象
(4)给成员变量赋值：
A:无参+setXxx()
B:带参
(5)一个标准的代码：
class Student {
private String name;
private int age;
public Student() {}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void show() {
System.out.println("姓名是："+name+",年龄是："+age);
}
}
创建对象：
(1)加载相应的类（静态成员这个时候分配空间，分配在方法区上的静态共享区），先加载父类后加载当前类
(2)在堆中分配空间（调用本来构造方法，构造方法第一行是super()，所以会先初始化父类相关属性方法）（new）
(3)赋值给对应的形参，形参存储在相应线程线开辟的栈帧中
static关键字
(1)是一个状态修饰符。静态的意思
(2)它可以修饰成员变量和成员方法
(3)特点：
A:随着类的加载而加载
B:优先于对象存在
C:被所有对象共享
这也是判断我们是不是该使用静态的条件
举例：饮水机和水杯例子。
D:可以通过类名调用
静态修饰的内容，可以通过类名调用，也可以通过对象名调用
在类中的位置可前可后，不影响调用（即静态方法下面申明的静态成员变量也可以被写在上面的静态方法使用）
(4)方法访问特点
A:普通成员方法 可以访问静态的
B:静态成员方法 静态只能访问静态的
注：静态中是不能有this的（加载时间不同）。
静态成员变量和普通成员变量的区别(理解)
(1)所属不同
静态属于类，称为类变量，可以用类名直接调用
非静态属于对象，称为实例变量
(2)内存空间不同
静态在方法区的静态区
非静态在堆内存
(3)生命周期不同
静态随着类的加载而加载，随着类的消失而消失
非静态随着对象的创建而存在，随着对象的消失而消失
(4)调用不同
静态可以通过类名调用，也可以通过对象名调用。建议通过类名调用
非静态只能通过对象名调用
main方法是静态的 public static void main(String[] args)
Math类
(1)Math:针对数学进行运算的类
(2)特点：没有构造方法，因为它的成员都是静态的
(3)产生随机数：
public static double random(): 产生随机数，范围[0.0,1.0)
(4)产生1-100之间的随机数
int number = (int)(Math.random()*100)+1;
代码块
(1)在java中用{}起来的代码
(2)分类：
局部代码块：在方法中。限定变量生命周期，及早释放，提高内存使用率
构造代码块：在类中方法外。
把多个构造中的相同代码用一个构造代码块体现，每次创建对象都会自动调用。
静态代码块：在类中方法外，用static修饰。
对类中的数据进行初始化。仅仅执行一次。
继承
(1)把多个类中相同的属性和行为提取出来，定义到一个类中，
然后让这多个类和这一个类产生一个关系，这多个类就具备这一个类的属性和行为了。
这种关系叫：继承。
(2)继承如何表示的呢?
格式：class 子类名 extends 父类名 {}
(3)java中的继承特点：
A:java中只能单继承
B:java中可以多层继承。(继承体系)
(4)java中的继承的好处和弊端
A:好处
a:提高了代码的复用性
b:提高了代码的可维护性
c:让类与类之间产生了一个关系，是多态的前提
B:弊端
让类与类的耦合增强了。这样一个类的改动会直接影响另一个类。
设计原则：高内聚，低耦合。
(5)java中的继承的注意事项：
A:私有成员不能被继承
B:构造方法不能被继承，想访问，通过super关键字
C:不能为了部分功能而去使用继承
(6)继承中的成员关系：
A:成员变量
不同名：特别简单，一看就知道用的是谁。
同名：就近原则
访问自己的用this
访问父亲的用super
B:构造方法
a:子类的所有构造方法默认都是访问父类的无参构造方法
b:如果父类没有无参构造方法，怎么办呢?
通过super(...)访问父类带参构造方法
通过this(...)访问本类其他构造方法。(一定要有一个访问了父类的构造方法)
注意：super或者this同时只能出现一个，并且只能在语句的第一条语句。
为什么呢?
因为子类可能会访问父类的数据，所以，在子类初始化之前，要先把父类数据初始化完毕。
C:成员方法
不同名：特别简单，一看就知道用的是谁。
同名：就近原则
访问自己的用this
访问父亲的用super
(7)this和super的区别及应用场景
A:区别
this：本类对象的引用
super：父类存储空间的标识。可以理解为父类对象的引用。
B:应用场景
a:成员变量
this.变量 本类的成员变量
super.变量 父类的成员变量
b:构造方法
this(...) 本类的构造方法
super(...) 父类的构造方法
c:成员方法
this.方法名(...) 本类的成员方法
super.方法名(...) 父类的成员方法
方法重写
(1)描述：在子类中，出现了和父类中一模一样的方法声明的现象。
(2)作用：可以使用父类功能，还可以增强该功能。
(3)面试题：
override和overload的区别?
overload可以改变返回值类型吗?
(4)方法重写的注意事项：
A:父类私有方法不能被重写
B:子类重写方法的访问权限不能比父类的方法低
C:静态只能重写静态。(其实这算不上重写)
final关键字
(1)final:最终的意思
(2)作用：可以修饰类，修饰成员变量，修饰成员方法
(3)特点：
A:修饰类 类不能被继承
B:修饰成员变量 变量变成了常量
C:修饰成员方法 方法不能被重写
多态
(1)多态：同一个对象，在不同时刻表现出来的多种状态
举例：水，猫和动物
(2)多态的前提：
A:有继承关系
B:有方法重写
C:有父类引用指向子类对象
(3)多态中的成员访问特点：
A:成员变量
编译看左边，运行看左边
B:成员方法
编译看左边，运行看右边
C:静态方法
编译看左边，运行看左边
为什么：
因为方法有重写，而变量没有。静态方法没有重写一说。
多态
(1)同一个事物在不同时刻表现出现的多种状态。
举例：水，猫和动物
(2)前提
A:有继承或者实现关系
B:有方法重写
因为抽象类中的抽象方法以及接口中的方法都必须被子类重写，调用才有意义。
C:有父类或者父接口引用指向子类对象
(3)多态中的成员访问特点
Fu f = new Zi();
A:成员变量
编译看左边，运行看左边
B:成员方法
编译看左边，运行看右边
C:静态方法
编译看左边，运行看左边
(4)好处和弊端
A:好处
提高了代码的维护性
提高了代码的扩展性
B:弊端
不能访问子类特有功能
(5)如何访问子类特有功能
A:创建子类对象
B:向下转型
(6)多态中的转型
A:向上转型
子到父
B:向下转型
父到子(加强制转换)
抽象类 abstract修饰的类
(1)有些时候，我们对事物不能用具体的东西来描述，这个时候就应该把事物定义为抽象类。
(2)抽象类的特点：
A:抽象类或者抽象方法必须用abstract修饰
B:抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
可以按照多态的方式实例化。
D:抽象类的子类
a:要么是抽象类
b:要么重写抽象类中的所有抽象方法
(3)抽象类的成员特点：
A:成员变量
可以是变量，也可以是常量
B:构造方法
有。
不能实例化，有构造方法有什么意义呢?
用于子类访问父类数据的初始化。
C:成员方法
可以是抽象的，也可以是非抽象的
(4)两个小问题
A:如果你看到一个抽象类中居然没有抽象方法,这个抽象类的意义何在?
不让别人创建
B:abstract不能和哪些关键字共存?
a:private 冲突
b:final 冲突
c:static 无意义
接口 关键字interface
(1)有些时候，不是事物本身具备的功能，我们就考虑使用接口来扩展。
(2)接口的特点：
A:定义接口用关键字interface
格式是：interface 接口名 {}
B:类实现接口用关键字implements
格式是：class 类名 implements 接口名 {}
C:接口不能实例化
D:接口的子类
a:要么是抽象类
b:要么重写接口中的所有方法
(3)接口的成员特点
A:成员变量
只能是常量。
默认修饰符：public static final
B:成员方法
只能是抽象方法。
默认修饰符：public abstract
推荐：
建议自己写接口的时候，把默认修饰符加上。
(4)类与接口的关系
A:类与类
继承关系，只能单继承，可以多层继承。
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时实现多个接口。
C:接口与接口
继承关系，可以单继承，也可以多继承。
(5)抽象类和接口的区别?
A:成员区别
B:关系区别
C:设计理念区别
抽象类：父抽象类，里面定义的是共性内容。
接口：父接口，里面定义的是扩展内容。
形式参数和返回值问题
(1)形式参数：
基本类型：需要的是对应的值
引用类型：
类：该类的对象
抽象类：该类的子类对象
接口：该接口的实现类对象
(2)返回值问题：
基本类型：返回的是对应的值
引用类型：
类：该类的对象
抽象类：该类的子类对象
接口：该接口的实现类对象
(3)链式编程
new A().b().c().d();
包
(1)其实就是文件夹
(2)对类进行分类管理
(3)格式：
package 包名;
(4)注意事项
A:package是程序中的第一条可执行语句
B:在类中package是唯一的
C:没有package，默认是无包名
(5)带包的类的编译和运行
导包(理解)
(1)为了方便使用不同包下的类，需要导包
(2)格式：
import 包名.报名...类名;
注意：可以导入到*,但是不建议
(3)package，import，class在类中有没有顺序关系呢?
有。
package --> import --> class
修饰符
(1)4种权限修饰符
本类 同一个包下 不同包下的子类 不同包下的其他类
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
(2)常见的修饰
A:类 public
B:成员变量 private
C:构造方法 public
D:成员方法 public
内部类
(1)把类A定义在类B内部，类A就被称为内部类
(2)访问特点：
A:内部类可以直接访问外部类的成员，包括私有
B:外部类要想访问内部类的成员，必须创建对象
(3)内部类的分类：
A:成员内部类
B:局部内部类
(4)成员内部类
A:private
B:static
(5)局部内部类
局部内部类访问局部变量，必须加final修饰
(6)匿名内部类
A:没有名字的内部类
B:前提
存在一个类或者接口
C:格式
new 类名或者接口名() { // 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，作用提供对象
重写方法();
};
本质：是一个匿名子类对象
(7)开发中如何使用
不用在定义一个新的类了。直接通过匿名内部类的格式就可以搞定
interface Person {
public abstract void show();
}
class PersonDemo {
public void method(Person p) {
p.show();
}
}
PersonDemo pd = new PersonDemo();
pd.method(new Person(){
public void show(){...}
});
(8)面试题
补齐代码，在控制台输出HelloWorld
interface Inter {
public abstract void show();
}
class Outer {
//补齐代码
public static Inter method() {
return new Inter(){
public void show() {
System.out.println("helloworld");
}
};
}
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
Eclipse的快捷键
A:内容辅助键
alt+/
补全main：main + alt+/
补全输出语句：syso + alt+/
B:常用快捷键
a:格式化
ctrl+shift+f
b:导包
ctrl+shift+o
c:注释
ctrl+/
Eclipse中debug
A:debug的作用
a:调试错误
b:查看程序的执行流程
B:查看程序的执行流程
a:如何加断点
在代码区域的左边双击即可
b:在哪里加断点
哪里不会加哪里。
注意：不要加在类名上或者方法名上
c:观看哪些地方
代码的执行流程
变量的变化过程
控制台的输出结果
d:如何让程序一步步执行
按F6
e:如何去除断点
再次双击
找到debug界面，有一个breakpoints里面的两个x的地方
三种常用的debug，debug中改变变量值方法
a:Variables界面 直接找到相应变量 右击 然后选择change value
b:Expressions界面 Add new expression ，通过添加表达式的方式，修改变量的值
c:Debug Shell界面 此处可以直接运行java代码，通过java代码，更改变量值（3种中最强大的一种，不仅可以改变值，还能够临时添加变量等）
1466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
