目录
- 一、第一节 前期准备
- 第二节 java语法基础
- 第三节 方法
- 第四节 数组
- 第五节 面向对象
- 第六节 第十三节 形式参数
- 第七节 封装
- 第八节 This关键字
- 第九节 继承
- 第十节 继承中成员方法的关系
- 第十一节 多态
- 第十二节 抽象类
- 第十三节 接口
- 第十四节 形参和返回值
- 第十五节 包
- 第十六节 权限修饰符
- 第十七节 内部类
- 第十八节 Scanner
- 第十九节 String和StringBuffer
- 第十九节 包装类型
- 1. 将基本数据类型封装成对象的好处：
- 第二十节 math
- 1. 获取任意范围的随机数
- 2. 任意数简便方法
- 第二十一节 system
- 第二十二节 BigInteger
- 第二十三节 Date
- 第二十四节 日历类 calendar
- 第二十五节 对象数组
- 第二十六节 泛型
- 第二十七节 泛型通配符
- 第二十八节 可变参数
- 第二十九节. 异常处理
- 第二十九节 计时器的使用
一、第一节 前期准备
1. 熟悉基本的Dos命令
- d: 盘符切换
- dir 列出当前目录下的所有文件
- md 创建目录
- rd 删除目录 删除文件夹
- cd 改变指定目录
- cd… 退回到上一级目录
- cd\ 退回到根目录
- del 删除文件
- exit 退出dos 命令行
- cls 清屏
2. java语言基础
2.1.java语言特点：
简单性 解释性
面向对象 高性能
分布式处理 多线程
健壮性 动态
结构中立 安全性
开源
跨平台
2.2 JRE和jdk
JRE是Java的运行环境
JDK是java的开发工具包 开发环境
简而言之：使用JDK开发完成的java程序，交给JRE去运行
JAVA 程序具有跨平台的特性 而JVM没有
JDK 下载www.oracl.com
下载不同版本的JDK 下载7U60
安装的时候 安装目录一定不要有特殊符号
2.3 第一个java程序
首先定义一个类 : class 类名
在类定义后加上一对大括号 { }
在大括号中间添加一个主（main）方法/函数 Public static void main（String [] args）{ }
在主方法的大括号中间添加一行输出语句 System.out.println （“hello world”）;
具体的操作
首先编写JAVA源代码程序 扩展名 .java
在命令行模式中输入javac命令对源代码进行编译，生成字节码文件
Javac源文件名.java
编译完成后，如果没有报错信息，输入java命令对class字节码文件进行解释运行，执行时不需要添加.class扩展名
例如：Java Demo
2.4 JAVA运行与工作原理
Java源代码 -----> javac-------------------------->java执行------->运行结果
Helloworld.java 编译 java字节码文件
Java 语言严格区分大小写
因为程序执行时需要使用外部指令javac 但是javac指令仅仅能在JDK安装目录下的bin目录下使用，因此程序只能写入bin目录
程序开发过程中，不能将源代码写入JDK的安装目录，因此需要将源程序保存到任意位置的制定目录 所以需要时javac指令在任意目录下可以运行
2.5classpath环境变量的配置
使classpath目录下的.class文件可以在人任意目录中使用
Path与Classpath的区别
Path环境变量里记录的是可执行文件 对于可执行文件先到当前路径去找，如果没有找到，就去path环境变量配置路径里面去找
Classpath 环境变量里记录的是java类的运行文件所在目录
第二节 java语法基础
1. 关键字
被java语言赋予特定含义的单词
.组成关键字的字母全部都小写
关键字注意事项：
- goto 和 const 作为保留字存在，目前并不使用
- 类型Notepad++这样的高级记事本，针对关键字有特色的颜色标记
2. 标识符
2.1 定义：
给类方法 接口 变量取得名字就是标识符
①. 英文字母大小写
②. 数字字符
③. $和_
注意事项：
①．不能以数字开头
②．不能是java中的关键字
③．严格区分大小写
命名规则：
①. 见名知意
②. 包：其实就是文件夹 用于把相同文件名的文件区分
单级 ： chengxu
多级 ：com.ziji
④．类或者接口：
一个单词：单词的首字母必须大写
多个单词：每个单词的首字母都必须大写
⑤．方法或者变量
一个单词：单词的首字母小写
多个单词：从第二个单词开始，每个单词的首字母必大写
⑥.常量：
一个单词：单词的首字母小写
多个单词：每个字母都大写
3 注释：
用于解释说明程序的文字
单行注释 //
多行注释 /* * /
文档注释 /** */
多行注释不可嵌套使用，单行注释可以嵌套使用
先写注释 在写代码
注释的作用：
- 解释说明程序，提高程序的可读性
- 可以帮助我们调试程序
4. 常量：
在代码执行过程中，其值不发生改变
4.1 分类
A：字符串常量 用--*双引号*--括起来的内容
B：整数常量
C：小数常量
D：字符常量： 用--*单引号*--括起来的内容
E：bool常量 只用ture false
F: 空常量 null
自定义常量
4.2 java针对整数常量的四种表现形式
二进制：以 0 1组成 以Ob开头
八进制：以O开头
十进制
十六进制：以OX开头
原码: 最高位表示符号 0表示正数 1表示负数
反码：正数的反码与原码相同
负数的反码与原码取反（符号位不变）
补码: 正数的补码与原码相同
负数的补码是在反码的基础上加一
5. 变量：
定义：在执行程序的过程中，其值在一定范围改变得量
5.1 组成规则
限定其数据类型
初始化值
变量名 运算时使用该空间的值
Int x=5；数据类型 数据名=初始化值
6数据类型
6.1 定义：
数据类型：java是一种强类型语言，针对每一种数据都定义了明确的数据类型
6.2 分类
| 基本数据类型 | int等（ 四类 八种） |
|---|---|
| 引用数据类型 | 类 接口 数值 |
整型：默认情况是int型
| 整型 | 字节 |
|---|---|
| Byte | 1 |
| Short | 2 |
| int | 4 |
| Long | 8 |
浮点型：默认情况是 double
| 浮点型 | 字节数 |
|---|---|
| float | 4 |
| – | – |
| Double | 8 |
字符类型
Char 2个字节
布尔类型 true false
使用变量的注意事项：
A：作用域问题
在一个大括号内不能定义两个变量名相同的变量
B：初始化
- 没有初始化值的变量不能直接使用
- 在使用之前给值就行
- 最好在定义的时候直接初始化
7 运算符
- ‘+’ 加法
- ‘-’减法
- ‘* ’ 乘法
/ 除法 没有余数
% 求余数
在运算过程中只要运算对象类型必须一致
运算过程中 默认转换
Byte–short-- char-- int-- long-- flaot–double
Byte short char类型之间不会相互转换 默认为int 并且超过范围就会报错
类型转换可能会造成精度缺失
强制转换：目标类型 变量名=（目标类型）（被转换数据）
byte b1=3,b2=4,b;
b=b1+b2;
变量计算的时候:
- 先提升数据类型，在计算
- //b=3+4; 先运算，在赋值，然后再看数据类型是否一致
字符串数据和其他数据做+,结果是字符串类型
+：是连接作用 字符串连接符
数据类型中的问题： - 在定义long或者float 类型的时候要加L或者f
- 整数默认是int 类型 浮点数类型默认的是double
7.1 位运算
^的特点：一个数据被另一个数据位异或两次，该数字不变
位运算符：
要做位运算 必须先把数据转换为二进制
<<左移
'>>'右移
">>>'无符号位移
&位运算 二进制 有0则0
|位或运算 二进制 有1则1
^ 相同则0 不同则1
~ 按位取反运算符 0变1 1变0
换数字：
<< : 左移 左边最高位丢弃，右边补齐
>> ：最高位是0，左边补齐0 ，最高位是1，左边补齐1
>>> 无符号右移 无论最高位是0 还是1 左边补齐0
左移是乘法 乘以2的移动次方（正数）
右移是除法，除以2的移动次方（正数）
7.2 三目运算符
格式： 比较表达式？表达式1：表达式2；
比较表达式：结果是一个bool类型 返回ture或者false
- 如果为true 就把表达式1作为结果
- 如果为false 就把表达式2 作为结果
eg:
int z=（x>y）?x:y;
8 键盘录入基本数据格式：
- 导包： import.java.util.Scanner 位置：在class上面
- 创建键盘录入对象 格式：Scanner sc=new Scanner(System.in);
- 通过对象获取数据 格式：int x= sc.nextInt();
第三节 方法
1.定义：
完成特定功能的代码块
注意：
java中的函数称为方法
2.格式:
修饰符 返回值类型 方法名（参数数据类型 参数名1，参数类型 参数名2）{
Return 0;
}
| 修饰符： | 目前就用 public static 。。。。。 |
| 返回值类型， | 就是功能结果放入数据类型 |
| 方法名： | 符合命名规则即可 |
| 参数： | 1. 实际参数：就是实际参与运算的 2. 形式参数：就是方法顶以上的，用于接受实际参数的 |
| 返回值： | 就是功能的结果，由return 带给调用者 |
方法的执行特点:不调用不执行
方法的注意事项：
- 方法不调用不执行
- 方法与方法是平级关系，不能嵌套定义
- 方法定义的时候参数之间用逗号隔开
- 方法调用的时候不用再传递数据类型
- 如果有返回值，一定要用return 带回一个值
方法重载： - 在同同一个勒种，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可
- 方法重载的特点：
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法 参数个数和参数类型不同
第四节 数组
1.数组的概念
数组是存储同一种数据类型多个元素的集合，也可以看成一个容器
数组既可以存储基本数据类型，也可以存储引用数据类型
2.数组的定义格式
| 格式一： | 数据类型 [ ] 数组名 int [] a定义一个int类型的数组a变量 |
| 格式二： | 数据类型 数组名【】 int a【】定义一个int类型的a数组变量 |
两种其实一样只是念法上有点不同
注意：
对数组元素进行初始化:
- 动态初始化 只指定长度，有系统给出初始化的值
动态初始化的格式：
数据类型 【】 数组名 = new 数据类型[数组长度]
Eg： int【】 arr = new int 【300】； - 静态初始化 给出初始化 的值，有系统决定长度
格式： 数据类型 【】 数组名 = new 数据类型 【】 {元素一，元素二，…} - Int 【】arr=new int 【】{1，2,3}；
- Int 【】arr ={1,2.3}
注意：不要同时动态和静态进行
两个问题： 访问了不存在的索引
数组已经不再指向堆内存了，而你还用数组名去访问
Class Array {
Public static void main (String [] args){
Int [] arr= {1,2,3};
System.out.printin(arr[3]);
//引用类型的常量；空常量 null
Arr = null；
System.out.printin(arr[0]);
}
}
3. 二维数组
3.1 定义格式：
- 数组类型 【】【】变量名 = new 数据类型【m】【n】
- 数组类型 数组名 【】【】= new 数据类型 【】【】
- 数据类型 【】数组名 【】=new 数据类型【】【】
M表示这个二维数组有多少个一维数组
N 表示每一个一维数组的元素个数
Int 【】【】arr = new int 【3】【2】
定义了一个二维数组 arr
3.2 另一种格式：
数据类型 【】【】 变量名 = new 数据类型 【m】【】
M表示这个二维数组有多少个一维数组
Eg:
Int 【】【】arr=new int[3][]
arr[0] = new int [2]
arr[1] = new int [3]
arr[2] = new int [1]
3.3.还有一种格式:
数据类型【】【】变量名=new 数据类型【】【】{{元素1，元元素2}，{…},{…}}
简化版的格式：
数据类型【】【】 变量名= {{…}，{…}，{…},{…}}
Int [][] arr={{1,2,3},{1,2},{1}};
二维数组的遍历：
package com.summer002.com;
import java.util.Scanner;
//二维数组的遍历
public class summer03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入12个数字:");
Scanner sc = new Scanner(System.in);
int[][] arr = new int[4][3];
for (int i = 0; i <4; i++) {
for (int j = 0; j < 3; j++) {
arr[i][j] = sc.nextInt();
System.out.println("。。。。。。。。。。。。。。。。。。。。。。。。。 ");
}
}
// int x = 0;
// for (int i = 0; i < 4; i++) {
// for (int j = 0; j < 3; j++) {
// System.out.print(arr[i][j]);
//
// x++;
// if (x % 3 == 0) {
// System.out.println("\n");
//
// }
// }
// }
System.out.println("*********************************");
int t = 0;
for (int i = 0; i<arr.length; i++) {
for (int j = 0; j<arr[i].length; j++) {
System.out.print(arr[i][j]);
t++;
if (t % 5 == 0) {
System.out.println("\n");
}
}
}
}
}
第五节 面向对象
1.成员变量和局部变量的区别：
- 在类的位置不同：
成员变量：在类的方法外
局部变量：在方法定义中或者方法声明上 - 在内存的位置不同
成员变量：在堆内存
局部变量：在栈内存 - 生命周期不同：
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 - 初始化值不同：
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值才可使用
注意事项：- 局部变量名称可以与成员变量的名字一样，在类中使用的是就近原则
- 引用类型包括：接口，类
- 如果看到调用一个类方法中传入的参数是一个类对象，那么就应该传入该类的一个对象
第六节 第十三节 形式参数
1.形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型： 形式参数的改变直接影响实际参数
2.匿名对象
匿名对象就是没有名字的对象 是一种简化表示形式
匿名对象的两种使用情况：
1. 对象调用方法仅仅一个的时候
2. 作为实际参数传递
匿名对象被调用完以后就是垃圾，空间及被释放
带名字的对象
Student s=new student（）；
S. show（）；
不带名字的对象==匿名对象：
New Student（）；
New Student（）.show（）；
第七节 封装
1.Private ：
私有的，可以修饰 成员变量和成员方法
被private修饰的成员只能在本类中使用
- 封装的作用：隐藏对象的属性和实现细节，紧对外提供公共访问方式
- 封装的好处：
1. 隐藏实现的细节，提供公共的访问方式
2. 提高了代码的复用性
3. 提高安全性 - 封装的原则：
A. 将不需要对外提供的内容隐藏起来
B. 把属性隐藏起来，提供公共方法对其访问 - Private关键字最常见的应用
- 把成员变量用private修饰
- 提供对应的get xxx（）和set xxx （）方法
package com.summer002.com;
//封装和private应用
public class practice001 {
private int age=10;
private String name="tjk";
//获取值
public int getage(){
return age;
}
//年龄赋值
public void setage(int a) {
age=a;
}
//姓名获取值
public String getname(){
return name;
}
//姓名的赋值
public void setname(String n){
name=n;
}
}
《》《》《》《》《》《》《》《》《》《》《》《》《》《》《》《》
package com.summer002.com;
public class practice002 {
public static void main(String[] arges) {
//创建学生对象
practice001 p=new practice001();
//使用成员变量
System.out.println(p.getname()+".............."+p.getage());
p.setage(12);
int n=p.getage();
System.out.println(n)；
}
}
第八节 This关键字
1.构造方法
1.1 构造方法作用的概述：
给对象的数据进行初始化
1.2 构造方法的格式：
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
1.3 构造方法注意事项
如果你不提供构造方法，系统会给出默认的构造方法
如果你提供了构造方法，系统将不再提供
构造方法是可以重载的
2.静态变量和成员变量的区别
- 静态变量所属类 所以也称为类变量
- 成员变量属于对象，所以也称为实例对象
- 静态变量存储于方法区为静态区
- 成员变量是存储于堆内存
- 静态变量随类的加载而加载，消失而消失
- 成员变量随对象的创建而存在
- 静态变量可以通过类型调用，也可以通过对象调用
- 成员变量只能通过对象名调用
Mian方法也是静态的
在同一个文件夹下，类定义在两个文件夹和定义在一个文件夹下其实是一样的
3.如何做一个说明书
A：写一个工具类
B:对这个类加入文档注释
加写？？？
/**
*@作者
*@版本
*这是。。。。。。。。。
*/
4.制作说明文档
Javadoc –d doc –author –version 编译的文件
Java.lang下面的包不需要导入
5.导包
简单的看看解释说明 看版本
- 看类的结构
成员变量 字段摘要
构造方法 构造方法摘要
成员方法 方法摘要 - 学习构造方法
有构造方法 就创建对象
无构造方法 成员可能都是静态的 - 看成员方法
- 左边
是否静态： 如果静态，可以通过类名调用
返回值类型 - 右边
看方法名：方法名称
参数列表
6.代码块:
在java 中使用{括起来的代码称为代码块}
- 局部代码块：局部位置，用于限定变量生命周期
- 构造代码块：再类的成员变量位置 用{}每次调用构造方法都会先调用构造代码块
作用：可以吧多个构造方法中的共同代码放一起 - 静态代码块：在类中的成员位置，用{}括起来的代码只不过 用static修饰
面试题：
静态代码块 构造代码块 构造方法的执行顺序
①静态代码块 ②构造代码块 ③ 构造方法
静态代码块只执行一次
每次调用构造方法都执行
第九节 继承
在多个类中存在相同属性和行为时，将这些内容抽型到单独一个类中，哪么多个类中无需在定义这些属性和行为，只需继承那个类即可。
1.实现继承：
Java 提供了关键字 extend
格式 class 字类名 extends父类名（）{}
- 好处：
A提高了代码的复用性
B 提高了代码的维护性
C让类与类之间产生了关系，最多太的前提 - 弊端“
- ”类与类产生的关系，其实也是继承的一个弊端
- 类的综合性增强了
开发的原则：低耦合，高内聚
| 耦合： | 类与类的关系 |
| 内聚： | 就是自己完成某件事的能力 |
特点：java中只支持单继承 不支持多继承
但是支持多层继承
注意事项：
- 子类只能继承父类所有非私有的成员（成员方法 和成员变量）（打破了封装性）
- 子类不能继承父类的私有方法
- 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法。
- 不要为了部分功能去继承
- 什么时候用继承
继承体现了 is a 的关系
如果有两个类A B 只要符合a是b的一种 或者B是a的一种
子类中的成员变量和父类中的成员变量名字不影响
继承之后就近原则赋值
A． 在子类中的局部范围找，有就是用
B． 在子类的成员范围找，有就使用
C． 咋父类的成员范围找,有就使用
D． 如果还找不到，就报错
输出子类成员变量的值
2.输出父类的成员变量的值
This 代表本类对象的引用
Super 可以操作父类的成员 父类的存储空间的标记 仅仅表示先初始化父类数据在初始化子类数据
A．
This.成员变量 调用本类的成员变量
Super. 成员变量 调用父类的成员变量
B．
调用构造方法
This. 构造方法 调用本类的构造方法
Super. 构造方法 调用父类的构造方法
C．调用成员方法
This.成员方法 调用本类的成员方法
Super.成员方法 调用父类的成员方法
子类的所有构造方法都会默认访问父类的所有无参构造
原因：因为子类在继承父类的方法是 同时还会继承父类的数据
因为子类每一个构造方法的第一条语句默认都是
super（）
3.如果父类中没有无参构造，那么
1.在父类中加一个无参构造
2.通过使用super关键字去显示的调用父类的带参构造方法
3.子类通过this去掉用本类的构造方法 子类中必序有一个去访问父类的无参构造
必须放在第一条，若不是则就有可能对父类的数据进行多次初始化
第十节 继承中成员方法的关系
1.子类中的方法和父类中的方法一样时
先调用子类的方法
再看父类中有没有这个方法
如果没有就报错
2.方法重写
子类中出现了和父类中方法声明一样
首先使用子类的 若没有则使用父类的
3.方法重载
子类中出现了和父类中方法声明一样 参数列表不一样
方法重写的应用：
打工资类需要父类的功能，而功能却不能满足现状 这样就定义了子类特有的功能
注意事项：
- 父类中的私有方法不能够重写
父类的私有方法子类不可以继承 - 子类重写父类方法时 权限不能再低
最好一致 - 父类的静态方法 子类必须静态重写
第十一节 多态
1.定义：
同一个对象（事务） 在不同的时刻体现的不同状态
2.多态的前提:
- A． 要有继承关系
- B． 要有方法重写
- C． 要有父类引用指向子类对象
父 f = new 子
3.多态中的成员访问特点
- A． 成员变量
编译看左边，运行看左边 - B． 构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化 - C． 成员方法
编译看左边，运行看右边 - D． 静态方法
编译看左边，运行看右边
由于成员方法存在方法重写，所以看右边
4.多态的好处
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
A． 提高了代码的维护性（继承保证）
B． 提高了代码的扩展性（由多态保证）
在测试类中添加静态类 可以直接由创建对象，
将对象传入静态方法中，直接调用静态方法中的所有方法
传入静态方法的是父类的对象
5.多态得弊端 不能调用子类的特有功能
但是如果想用的话
可以：
- A.创建子类的对象方法即可
- B．把父类的引用强制转换为子类的引用（向下转型）
6.对象间的转型问题：
| 向上转型： | fu f=new zi（）； |
| 向下转型： | zi z=（zi）fu（）；//要求该f必须是能够转换为zi的 |
- 继承的时候：
A. 子类中有和父类一样的方法，叫做重写
B. 子类中没有父类中出现的方法叫做继承
第十二节 抽象类
1.类中如果有抽象方法，该类比定义抽象类
抽象类和抽象方法必须用abstract关键字修饰
1.1 格式
abstract class 类名{}
1.2 特点：
- A. 抽象类和抽象方法必须用abstract 关键字修饰
- B. 抽象方法不能有主体
- C. 抽象类中不一定有抽象方法，但是抽象方法的类必须定义为抽象类
- D. 抽象类不能实例化
因为他不是具体的
抽象类有构造方法，但是不能实例化 构造方法的作用是 用于子类访问父类数据的初始化 - E. 抽象类的子类
- 抽象类的子类是一个抽象类
- 如果不想重写抽象方法，盖子类是一个抽象类
- 重写所有的抽象方法，这个时候子类就是一个具体的类
- F. 抽象类的实例化其实是靠具体的子类实现的，是多态的方法
2.抽象类的成员特点：
| 成员变量： | 既可以是变量，也可以是常量 |
| 构造方法： | 用于子类访问父类数据的初始化 |
| 成员方法： | 既可以是抽象的，也可以是非抽象的 |
3.抽象类的成员方法特性：
- A． 抽象方法 强制要求子类做的事情
- B． 非抽象方法 子类继承的事情，提高代码的复用性
4.抽象类中的小问题：
一个类如果没有抽象方法，可以定义为抽象类
为了不让创建对象，只能在子类中创建对象调用他
非法修饰符组合 abstract 和private
final abstract void show（）{}
Static abstract void show() {}
第十三节 接口
1.接口的特点：
- A． 接口用关键字interface表示
格式：interface 接口名（）{} - B． 累的实现接口用implements表示
格式 class 类名 implements 接口名{} - C． 接口不能实例化
按照多态的方式，由具体的子类是泪花，实现的也是多态的一种 接口多态 - D． 接口的子类
要么是抽象类 意义不大
要么是接口的所有抽象方法的实现 具体类重写接口的所有抽象方法
由此可见：
A． 具体类多态
B． 抽象类多态（常用）
C． 接口多态（最常用）
2.接口成员的特点:
成员变量 接口中的变量默认为常量和静态的（默认）
自己手动给出 private static final num；
构造方法 无 所有类都默认继承一个object类
成员方法 接口方法必须是抽象的
3.类与类 接口与接口 接口与类的方法
类与类的关系：继承的关系，只能单继承
类与接口 实现关系 可以单实现，也可以多实现，也可以继承一个类的同时 实现多个接口
接口与接口 可以单继承，也可以多继承
4.抽象类与接口的区别
4.1成员区别：
- 抽象类：
成员变量：可以变量也可以常量
构造方法：有
成员方法： 可以抽象，也可以非抽象 - 接口：
成员变量：只可以是常量
成员方法：只可以是抽象
4.2关系区别
| 类与类： | 单继承 |
| 类与接口： | 实现 单继承 多实现 |
| 接口与接口： | 单继承 多继承 |
4.3设计理念
抽象类 按照继承体现是 is a的关系。抽象类中定义的是该继承体系的共性功能
接口 被实现体现的是like a 的关系，接口中定义的是该继承体系的扩展功能
第十四节 形参和返回值
1.参数的类型：
基本类型（太简单 ）
引用类型
- 类（匿名对象的时候）
- 抽象类 创建类不用接收 newstident().eat（）；
需要的是该抽象类的子类对象 - 接口 真正需要的是该接口的实现对象或者子类对象
2.返回值类型
基本类型：（太简单）
引用类型：
- 类：返回的是该类的对象 需要建一个该类的对象来接收
- 抽象类:返回值为抽象类的子类对象
- 接口:返回的是该接口的实现类的对象
链式编程：每次执行完返回的是一个对象
eg：(注意：中间有点)
对象.方法.方法
第十五节 包
1.包：
- A． 其实就是文件夹
- B． 作用：
- a. 把相同的类名方法破不同的包中
- b. 对类进行分类管理
方案一：按照功能分
方案二：按照模块分
2.包的定义
Package 包名
多级包用，分开即可
3.注意事项：
- A． package语句必须是程序的第一条可执行的代码
- B． package语句在一个java文件中只能有一个
- C． 如果没有package 就默认表示无包名
第十六节 权限修饰符
第十七节 内部类
1.内部类的概述
把类定义在其他类的内部，这个类被称为内部类
在类A中定义了一个类B，类B就是内部类
2.内部类的访问特点：
A． 内部类可以直接访问外部类的成员，包括私有
B． 外部类要访问内部类的成员，必须创建对象
3.内部类的位置
3.1. 成员位置：在成员位置定义的类 被称为成员内部类
局部位置定义的类被称为局部内部类
3.2 成员内部类：
如何直接访问内部类的成员
外部类.内部类 对象名=外部类对象.内部类对象
4.成员内部类的修饰符
内部类是为了不让外部直接访问所以：
Private修饰内部类
静态修饰是为了让外部直接用类名+方法名调用
内部类用静态修饰 是因为内部类可以看出外部类的成员
静态内部类访问外部类的数据只能是静态的
成员内部类被静态修饰后的访问方式
为了方便访问
格式： 外部类名.内部类名 对象名=new外部类名.内部类名（）；
内部类和外部类没有继承关系
通过外部类名限定this对象 外部类名.this.对象名
5.局部位置的内部类
A． 可以直接访问外部类的成员
B． 在局部位置，可以创建内部类对象，通过对象调用内部类的方法，来使用局部内部类功能
C． 局部内部类访问局部变量必须用final修饰
局部变量是随着方法的调用而调用
随着调用完毕而消失
而堆内存的内容并不会立即消失所以用final修饰
加入final修饰后这个变量就变成了常量
6.匿名内部类
就是内部类的简化写法
前提：
存在一个类或者接口
这里的类可以是具体类也是一个抽象类
格式：
New 类名或者接口名（）{
重写方法
}
本质是：
是一个继承了该类或者实现了该接口的子类匿名对象
7.面试题：
直接输出对象的名字就相当于string to string 输出
第十八节 Scanner
Scanner sc1=new scanner();
Sc1.nextint()
Sc1.nextline
先获取一个数值 在获取一个字符串会出现一个问题 数值丢失后面的值不让你输入
解决的办法： 创建两个对象
把所有的数据先按照字符串获取 然后要什么就转换成啥
第十九节 String和StringBuffer
1.String对象
- 字符串是最常见的操作
- 字符串是多个字符组成的数据 也可以看做一个字符数组
- 字符串是常量 初始化后不能改 但是字符串缓冲区可以更改
- 通过查看API 我们可以知道：
字符串‘’abc‘’是一个对象
- 面试题:
String s1=”hello”在栈里面创建 可以修改
String s2=new string(hello); 在堆里面创建 所以不能修改 在堆内存和方法区个创建一个对象
两个字符串接 先开空间 在拼接
如果是字符串是先加，再找有没有 如果有则直接返回 否则创建
2.StringBuffer
Stringbuffer 是字符串类型的一个缓冲区
有很多方法
Append 拼接
Tostring 转换成string类型
Stringbuffer sb=newstringbuffer（s） s为字符串//转换为stringbuffer类型
- 字符串的自反
第十九节 包装类型
1. 将基本数据类型封装成对象的好处：
可以在对象中定义更多的功能方法操作该数据
自动拆装箱 ：自动把基本类型改变为包装器类型 装箱
自动把包装器类型改变为基本类型 拆箱
只要是对象不能为空 要么就出现空指针异常
Java针对-128-----+127之间的数据做了一个数据缓冲池，每次不用创建 直接在缓冲池里面找就可以了
Interger的额数据直接赋值，如果在-128-----+127自检绘制就在缓冲池中获取数据
第二十节 math
1. 获取任意范围的随机数
Math类中的random方法
2. 任意数简便方法
- 有种子：
Random类
Random r=new random（种子数） - 无种子
Random r=new random（）； 会以时间为种子
Random r=new random（）； 会以时间为种子
r.nextint(int a) a为范围 该范围是小于a 大于0的随机数
第二十一节 system
1.system中的system.gs 启动垃圾回收机制
2.system.exit();
终止正在运行的java虚拟机，参数用作状态码 根据惯例 此方法用作出现异常
3.System.currentTimeMillis()
- 用以返回从1970年到现在的毫秒数
- 计算程序运行的时间
4.System.arraycopy(arr, 3, arr1, 0, 1);
将arr数组中的从第三个数组值 替换为arr1数组从第0个开始 第一个结束替换
第二十二节 BigInteger
1.biginteger 的方法
2.bigdecim方法
在java中运算的时候会出现0.01+0.09=0.099999999999999999999999这种情况 是因为浮点数造成精度误差，所以要用bigdecim方法
他也要有加减乘除方法 查api
第二十三节 Date
1.Date的构造方法
getTime（）；
gettime（long time）；
2.DateForamt：
可以进行日期和字符串的格式化和解析，但是由于抽象类所以必须使用子类simpleDateForamt 来使用
2.1将Date类型的转换为string
Date rq=new Date();
SimpleDateFormat adf=new SimpleDateFormat("y年-M月-d日-h时-m分-s秒-W周");
String sun1=adf.format(rq);//默认模式
System.out.println(sun1)
2.2将String类型的转换为Date类型的数据
注意： string 数据格式必须和SimpleDateFormat() 里面的格式要一样
第二十四节 日历类 calendar
1. calendar 类
Calendar c1=Calendar.getInstance();//子类对象
//System.out.println(c1);
int year=c1.get(Calendar.YEAR);
System.out.println(year);
getInstance() 是获取当前的时间 里面有获取当前时间的时分秒 更多
2.add方法和set方法
第二十五节 对象数组
1. 定义一个数组对象
shuzu [] sz=new shuzu[5];
2. 定有一个对象数组
shuzu s1=new shuzu(“林青霞”,25);
shuzu s2=new shuzu(“陈冠希”,26);
shuzu s3=new shuzu(“白百何”,27);
shuzu s4=new shuzu(“白百何”,28);
shuzu s5=new shuzu(“白百何”,29);
3. 将对象数组传给数组
sz[0]=s5;
sz[1]=s1;
sz[2]=s2;
sz[3]=s3;
sz[4]=s4;
4. 将数组对象用对象接收
shuzu s=sz[i];
System.out.println(s.getName()+
“============”+s.getAge());
第二十六节 泛型
1. 自动装箱
将基本类型自动装箱 这样基本类型就可以往集合里面放
软件出问题尽量早点出现问题
2.泛型
是一种把类型明确的工作推迟到创建对象或者条用方法的时候才去明确的特殊类型
格式：
<数据类型>
此处的数据类型只能是引用数据类型
3.泛型的好处
把运行时期的问题提前到编译阶段
避免了强制类型的转换
优化了程序设计，解决了黄色警告线
4. 泛型在哪里用
看API，如果接口 类 抽现货类后面跟有就说要使用泛型，一般都要在集合中使用
4.1 定义一个泛型类
public class practice2<T>{//定义了一个反省类
/*
*此类为student
*/
public void show(T t){
System.out.println(t);
}
创建一个泛型对象
practice2<String> p1=new practice2<String>();
p1.show("shenme");
只要创建的对象的泛型类和函数的泛型类相同就可以运行
4.2 定义一个泛型方法
public class practice2{
public <T> void add(T t){
System.out.println(t);
}
调用该方法
practice2 p1 = new practice2();
p1.add("shenmeam");
p1.add("是猪");
p1.add("你说是不是");
4.3 定义一个泛型接口
实现该接口
在测试类中实现的时候就必须规定类型
第二十七节 泛型通配符
1.泛型通配符
泛型如果明确写的时候前后必须一致<>这里面内容必须一致
？ 前后可以不一致 其意任意类型
Object前后必须一致
2.向下限定
可以创建子类是anmail的子类及自己
但是不能用object
3.向上限定
创建对象 的时候 可以创建自己和其父类
第二十八节 可变参数
1. 可变参数的格式
可变参数使用是在不知道该定义多少个参数是使用的
格式：
修饰符 返回值类型 方法名（数据类型….变量名）{
}
注意事项：
- 这里的变量其实就是一个数组
- 如果一个方法有可变参数，并且有多个参数，那么可变参数
肯定是最后一个
面向对象思想：
有哪些类
每个类有哪些东西
类与类之间的关系
多个对象公用一个成员变量用static
第二十九节. 异常处理
1. 异常：
程序出现了不正确的情况
| 编译期问题ActivictiveException | 必须进行处理如果不进行处理那么就运行不了 |
| 运行期问题 RuntimeException | 这个问题一般都是自己出现的问题 |
| 普通问题 : | Exception |
| 严重问题 : | Error 这种问题一般是比较严重的问题 比如 内存溢出 |
2. 异常处理
- A．try catch finally
- B．throws 抛出
一个异常
Try{
可能出现问题的代码
}catch（异常名 变量）{
针对问题处理
} try中的代码越少越好
多个异常处理
Try{
可能出现异常的语句
}catch（异常名 异常对象）{
}catch（异常名 异常对象）{
}
一旦try里面出现了问题，就会在这里吧问题给抛出去，然后和catch 里面的问题进行匹配 一旦有匹配就可以执行相应的catch里面的语句
注意事项：
- 能明确的尽量明确，不要用大的来处理
- 平级关系的异常顺序无所谓，如果出现了父子关系，父类必须在子类的后面
Jdk7新特性 处理异常的方案
Try{
}catch（异常名|异常名|异常名）{
}
批量处理异常 处理相同的提示信息的异常
这个方式虽然简洁但是
3. 处理方式是一致的
4. 多个异常之间必须是平级关系
| 编译期异常： | 必须显示处理 否则程序无法通过编译 |
| 运行时异常 | 无需显示处理亦可以和编译时异常一样处理（不处理可以） |
- Getmessage 方法是获取具体出现位置异常的字符串
- Tostring 方法返回异常的简单信息藐视
具体：此对象的类的name 全路径名
调用此对象 getLocalizedMessage（）方法的结果 如果不重写默认返回getmessage的内容
PrintatackTrace 将所有异常信息提供到控制台 包括类名 行号等等等等 系统默认调用
3.throws
Throws 异常类名
注意：
这个格式必须跟在方法的括号后面
尽量不要main方法上抛出异常
编译异常抛出，将来必须处理
运行期异常抛出，将来可以不处理
- 什么时候用throws
我们可以对有些异常进行处理，有些时候我们没有权限处理
或者是处理不了就不处理了
第二十九节 计时器的使用
1. 定时器
定时器可用于调度多个定时任务以后台线程的方石之幸，可通过Timer TimerTask类来实现定义调度的功能
依赖 Timer和TimerTask
*Timer:定时器类
*TimerTask：任务类
2.Timer类的方法：
Timer t1=new timer（）；
'延迟时间后执行 但是并未结束该任务'
t1.schedule(TimerTask (),延迟的时间)
'/延迟时间后执行 但是并未结束该任务'
t1.schedule(TimerTask (),延迟的时间)
要想让任务结束 就必须在timertask类中穿t1参数 然后在timertask类中 调用 t1. Cancel（）就可以将这个任务结束
t1.schedule(TimerTask (),延迟的时间，下一次开始的时间间隔)
Public Timer（）
最后一个是每隔多久执行一次
Mytask类会继承TimerTask 执行的代码就在MyTask中
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
