Java
1. 第一章
2. Java是一种面向对象的语言，和平台无关的语言，是一种强健的语言；
3. Java4中独立相关技术
a) Java虚拟机：the java Virtual Machine
b) 程序设计语言：the java programming language
c) 字节码文件格式：the java file format
d) 应用编程接口：the java Application Programminglnerface
4. Java的两种核心机制
a) Java虚拟机
b) 垃圾收集机制（Garbage collection）
5. Java配置环境变量
a) Path的配置：Java中bin目录的安装位置
b) Classpath的 配置：配置Java中编译好之后的.class存放位置方便
c) 编译：javac；运行：Java；测试环境变量有没有配好：Java – version
d) JDK工具是编译
e) JRE工具是运行
6. 命令提示符里用到的命令
a) cd..返回上一层，cls清空，-d ../目录+java.java（是指指定一个文件夹将编译的字节码文件放入），cd/d+目标文件（直接进入）
b) 第二章
i. 标识符
ii. Java语言中对各种变量、类、和方法等要素进行命名的字符序列叫做标识符
c) 命名规则：标识符的组成由字母，数字，$，下划线组成，不能以数字开头（不能以关键字命名）
d) 类的命名：首字母大写
e) 方法命名：首字母小写要根据驼峰规则，如果是拼接单词如：myInFor()，后边单词的首字母要大写
i. 关键字
ii. goto和const随未被使用，但关键字被保留
iii. 变量
iv. Java变量是程序中最小的存储单元，其要素包括变量类型，变量名，作用域
v. 从本质上讲，变量就是内存中的一小块区域。new出来的东西放在堆内存里，局部变量放在栈里
vi. 变量的划分（变量作用域）
1. 局部变量：方法或类语句块的内部定义的变量
2. 成员变量：方法外或者类的内部定义的变量
3. 数据类型的划分
vii. 基本数据类型：数值型，字符型（char），布尔型（boolean）
1. 数值型：整数数据类型 和 浮点数数据类型
a) 整数数据类型：byte，short，Int，long
b) 浮点数数据类型：float，double（浮点类型有固定的标表述范围和字符长度，不受平台影响）
2. 引用数据类型：类（class），接口（interface），数组
viii. byte：1字节，-2^7 – 2^7-1 int：4字节，-2^31 – 2^31-1
ix. char：2字节，-2^15 – 2^15-1 long：8字节，-2^63 – 2^63-1
x. short：2字节，-2^15 – 2^15-1
xi. float：4字节，-2^31 – 2^31-1 doble：8字节，-2^63 – 2^63-1
xii. 数据类型的转换
f) Java中的数据类型可以从任意数据类型转换为别的数据类型
g) 转换分为：隐式转换（默认转换）和显示转换（强制转换）
h) 数据转换原则：容量小的默认为转换成容量大的
i) 容量大小转换：byte,short,char->int->long->float->double
j) 5 .运算符
k) 包括：算术运算，逻辑运算，关系运算，赋值运算，三元运算
l) 算术运算符： +，-，*，/，%，++，--
m) 关系运算符： >，<，>=，<=，= =，!=
n) 逻辑运算符： !，& , | , ^ , &&，||
7. 6. &&, ||,! 逻辑运算符只能用于boolean身上
a) 位运算符： &，|，^，~ ， >>，<<，>>>
b) 赋值运算符： =
c) 扩展赋值运算符：+ =，- =，* =，/ =
d) 字符串连接运算符：+
e) 三目运算表达式：x？y：z
8. 使用顺序
| 1. . ( ) { } ; , 2. ++ -- ~ ! (data type) |
| 3. * / % |
| 4. + - |
| 5. << >> >>> |
| 6. < > <= >= instanceof |
| 7. == != |
| 8. & |
| 9. ^ |
| 10. | |
| 11. && |
| 12. || |
| 13. ? : |
| 14. = *= /= %= |
b) 从上到下由高到低
9. 表达式
a) 符合一定语法规则的运算符和操作数（a>b）；
10. 条件语句(根据不同的条件，执行不同的语句)
a) If
b) If……else
c) If…..elseif…..else
d) Switch（判断真假）{
1. Case：
}
e) 小心case穿透，switch的值必须是整型
11. 循环语句（重复执行）
a) for（int i>0；i<100；i++）{
}
b) while(条件判断)
c) 先判断在执行
d) do….while
e) 先执行，在判断（至少执行一次）
f) break：直接跳出循环
g) continue：终止本次循环，进入下次循环
12. 方法
a) 声明格式：修饰符修饰符返回值类型 方法名（形式参数）{
a) 语句块
b) }
c) 访问修饰符：private default protected public
d) 返回值类型：void int string char float等类型
e) Java中语言中使用下述形式调用方法：对象名方法名（实参）
f) Java中进行方调用中传递参数时遵循值穿递的原则：基本类型传递的是该数据本身。引用类型传递的是对对象的引用，而不是对象本身
13. 递归调用
a) 是指在方法执行过程中出现该方法本身的调用（对有规律可循）
b) 第五章
1. 数组
2. 定义：程序中相同类型的数据放到一起，用到的就是数组
3. 表示：Int a[] 或者int[] a
ii. 2. 数组概述
i. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
b) 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
2. 数组的声明
iii. 声明数组时不能指定其长度，例如：int a[5];//非法
iv. 数组初始化
v. 动态初始化：数组定义与为数组元素分配空间和赋值的操作分开进行
vi. 如：
public class Test {
a) publicstatic void main(String args[]) {
i. int a[];
ii. a = new int[3];
iii. a[0] = 3; a[1] = 9; a[2] = 8;
b) }
vii. }
viii. 静态初始化：在定义数组的同时就为数组元素分配空间并赋值
1. 如：public class Test {
2. public static void main(String args[]) {
i. inta[] = new int[]{ 3, 9, 8 };
3. }
ix. }
a) 数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化
x. 常见错误
xi. Java.lang ArrayIndexOfBoundsException(数组下标越界异常)
a) Int[] score2;
b) Scoer2 = {1,2,3,4};这样分开写会出现编译出错，创建数组并赋值的方式必须在一条语句中完成
xii. 数组中常用到的
xiii. 升序排序：Arrays.sort(数组名)；
xiv. 数组输出：Arrays.tostring(数组名);
xv. 扩展数组：int[]b= Arrays.copy of(a，a.length)，a指前一个数组，a.length指数组的长度
xvi. 数组拷贝： 如
a) Int[]a = {1,2,3,4,5};
xvii. int [] b = new int[a.length];
a) System.arraycopy(a, 0, b, 0, a.length);
xviii. 0就是下标从a数组开始，b，0就是下标从b数组开始
xix. Alt+shift+j：添加注释文档
xx. Alt+？：补全
xxi. Ctrl+shift+/：加多行注释
xxii. Ctrl+shift+\：取消注释
xxiii. Ctrl+shift+f：格式化
xxiv. Ctrl+鼠标左键
xxv. 数组常用排序方法：冒泡法（2个for循环，1个if），二分法
xxvi. 引用类型与整形的区别
xxvii. 引用类型指得是指向对象本身首地址
xxviii. 整数类型指自身
xxix. 二维数组
xxx. 定义：int[][] str = new int [2] [1]，可以一次性定义长度，但是初始化只能是高维到低维。
a) intt1[][] = new int[][4]; //非法
b) 静态初始化：
1. int intA[][] = {{1,2},{2,3},{3,4,5}};
2. int intB[3][2] = {{1,2},{2,3},{4,5}};//非法
c) 动态初始化：
d) int a[][] = new int[3][5];
1. int b[][] = new int[3][]
2. b[0] = new int[2];
3. b[1] = new int[3];
4. b[2] = new int[5];
14. 第六章 字符串
1. 定义：字符类型String 字符长度[]，字符名称
2. String[]str = “sfwefeww”
3. 如何获取字符串长度
4. 使用.lengrth() 方法
5. 字符串使用的方法
6. Equals(): 进行两个字符串对比看是否相等
i. s1.equals(s2) 或者 “发顺丰”.equals(“发顺丰”);
7. equalsIgnoreCase()：忽略大小写进行对比
i. favCourse1.equalsIgnoreCase(favCourse2)
b) toUpperCase()：将字符串转化成大写
i. favCourse1.toUpperCase().equals(favCourse2.toUpperCase())
8. toLowerCase：将字符串转换成小写
i. favCourse1.toLowerCase().equals(favCoures2.toLowerCase())
9. +、concat：拼接字符
a) Strings = new String("你好，");
b) Stringname = new String("张三！");
c) Stringsentence = s.concat(name);
d) System.out.println(sentence);
e) Substring（intI）：从第几个下标开始输出字符串
i. String a = str.Sbstring(5);
1. System.out.println(a);
f) Substring（int i，int j）：从第几个下标开始输出到第几个下标截止
i. String b = str.substring(3, 7);
1. System.out.println(b);
10. Str.trim()：去掉字符串中前端和后端的空格
i. System.out.println(str.trim());
11. Str.replaceAll（’char’，’char’）：替换字符，前边是要换掉的字符，后边是要换的字符 如：
a) String c= str.replace('就','好');
b) System.out.println(c);
12. charAt(int)：取单个字符,int值得是下标
a) char d = str.charAt(5);
b) System.out.println(d);
ii. endsWith(String)：//判断输入的字符串中是否以.java后缀结尾
a) System.out.println(num.endsWith(".java"));
iii. startsWitch(String) //判断输入的字符中是否是以“.J”开头的
a) System.out.println(add.startsWith(".J"));
iv. indexOf(String)：//用于查找第一次出现的位置从前到后
a) int at = str.indexOf("就");
i. System.out.println(at);
v. lastIndexOf: //从后向前查找第一次出现的字，下标不变
a) int st = str.lastIndexOf("的");
b) System.out.println(st);
vi. removeChar(String ,String):删除字符串，前边的是变量名，后边的是需要删除的字符
第三章 面向对象
1. 什么是类
a) 类就是模子
b) 确定对象将会拥有的特征（属性）和行为（方法）
2. 什么是对象
a) 对象就是类的具体实例化
b) 对象拥有属性和方法
对象拥有的静态特征叫做属性（属性描述可以描述实体量化的静态特征）
对象拥有的动态特征叫做方法（使用方法描述实体具体行为）
3. 如何创建一个对象
a) 使用关键字new，如：Fun fun =new Fun();
4. 类和对象的区别
a) 类是对象的模板
b) 对象是类的实例化
c) 以类的形式来组织代码
d) 以对象的形式来封装数据
e) 类是一个抽象的概念
f) 对象是类的具体实例
5. 如何定义一个类，类的属性和方法
a) 使用关键class ，如：public class Run{
public String name;
public 返回值类型（void） 方法名（school）(形参列表){
方法体
}
}
6. ToString()方法的优点
a) 不用先是调用，直接可以使用对象
7. 如何声明包
a) 关键字: package com.sxt.XXXXXX（域名倒置）
8. 如何导入包
a) Import java.util.Date; java.long.String
9. 为什么需要包
a) 包的好处
i) 文档分类别易于查找，易于管理
ii) 不同文档放在不同袋里拥有相同的名字，避免冲突
10. 在类中一个方法，如何调用本类的另一个方法
a) 对象名.方法名（）
11. 在类中一个方法，如何调用另一个类的方法
12. 什么是封装
a) 封装就是隐藏实现细节
b) 封装就是降属性私有化，提供公有方法访问私有属性
13. 封装的特性
a) 通过公有方法访问私有属性
c) 对象同时为具有属性和方法
如：privateString sun;
14. 什么是构造方法
a) 方法名和类名相同无返回值 如：
Public class Run{
public Run(){
}
}
15. 什么是方法重载
a) 方法名相同，方法参数列表不同
16. 什么是继承
a) 子类拥有父类的一般特性（它包括属性，行为），以及自身特有的特殊特性
b) 关键字是：extends 子类继承父类 如：public class Sun exitends S{}
c) 使用 super调用父类方法
17. 继承的好处
a) 提高了代码的复用性，可维护性
b) 继承符合is – a的特性
c) 不能违背代码重复“ write once ,only once”的特性
18. 什么是方法的重写
a) 子类和父类的方法具有相同的名称，参数列表，返回值类型（前提是子类继承父类 ）
如：public class Run{
public void sun(){
System.out.println(“很多好的话”);
}
Class Sut extends Run{
public void sun(){
System.out.println(“大家都很多护肤”);
}
}
}
19. Object
a) 所有java直接或者间接的继承了java.lang.Object
20. 什么是多态
a) 多态就是具有表现多种形态的能力的特征
b) 同一个实现接口，使用不同的实例二执行不同的操作
21. 如何实现多态
a) 子类重写父类方法
b) 编写方法时使用父类定义的方法
c) 运行时根据实际创建的对象类型动态决定使用哪个方法
22. 多态存在的三个必要条件
a) 要有继承
b) 要有方法重写
c) 父类引用指向子类对象
23. 多态的好处
a) 提高了代码的可扩展性和维护性
24. 什么是抽象类
a) 包含了抽象方法的类，使用关键字：abstract 修饰的类
25. 抽象方法
a) 只有方法的声明没有方法体 如： public abstract void Run();
26. 定义抽象方法
a) 该为定义为抽象类。子类必须重写父类的方法
27. 抽象方法的要点
a) 有抽象方法的类，只能定义为抽象类
b) 抽象类不能实例，既不能用new 来抽象化实例化
c) 抽象方法可以包含属性，方法，构造方法，但是构造方法不能用来构造new实例，只能用来被子类调用
d) 抽象类只能用来继承
e) 抽象方法必须被子类实现
28. 为什么需要抽象方法
a) 抽象方法是一种模板模式，抽象类为所有子类提供了一个抽象模板
b) 通过抽象类可以避免设计的随意性
c) 方法的设计和实现分离
29. 什么是接口
a) 比抽象还要抽象的类
b) 接口中只有抽象方法和常量
c) 定义接口用关键字：interface
30. 接口作用
a) 定义规范
b) 将规范和实例分离
c) 接口的本质是契约
d) 实现一个借口用：implements(实现)
31．为什么需要接口
a) 借口就是比抽象类还要抽象的抽象类，可以更加规范的对子类进行约束，全面的专业的实现类规范和具体现实的分离
b) 借口就是规范定义的一组规则，体现了现实世界中“如果你……..就必须的…….”思想
c) 接口的本质就是契约，就是法律，制定好大家遵守
（开发的是面向接口的编程）
31. 怎么定义接口
a) 访问修饰符 interface 接口名 extends 父接口1，父接口2…….
常量：/*blic static final*/ int A=10;
方法定义：/*public abstract*/ void syn();
b) 接口可以继承接口，类不可以继承接口
32. 怎么使用接口
a) 子类通过implements实现接口中的规范
b) 接口不能创建实例，但是可用于申明引用变量类型（多态）
c) 一个类实现了接口必须实现接口中所有的方法，并且这些方法只能是public
33. Final的用法
a) Final修饰的类不能被继承
b) String就是一个被final修饰的类，我们只能用不能被继承
c) Final不仅可以修饰类，还可以修饰变量，被final修士的变量就是一个长量，只能赋一次值
d) Final修饰的方法不能被子类重写
34. Final使用方法有两个
a) 把方法锁定，防止任何继承类修改它的意义和实现
b) 高效。编译器在遇到final方法时会转入内嵌机制，大大提高执行效率
35. Java中public ,private ,protected ,default之间的区别
a) Public修饰符：它具有最大的访问权限。它往往使用于对外的情况，也就是对象或类对外的一种接口形式。（可被所有其他子类访问）
b) Protected修饰符：主要作用保护子类。它的含义在与它的子类可以用它修饰的成员（不论该子类是不是同一个包下），它相当于传递给子类一种继承（自身，子类及同一个包的类可以访问）
c) Default修饰符： 有点的时候也成为friendly（友员），它是针对本报访问而设计的，任何处于本包状态下的类，接口，异常等都可以相互访问，即使父类没有用protected修士的成员变量（同一个包中的类可以访问，声明没有加修饰符，认为是friendly）
d) Private修饰符： 它的访问权限仅限于类的内部，是一种封装的体现。例如，大多数成员变量都是修饰符为private的，他们不希望其他外部类访问（只能被自己访问和修改）
扫一扫
243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
