Java基本语法-高级运用
Java基础语法—高级运用
- 计算机内存
- 内存的作用
- 如何使用内存
- 变量
- 使用变量
- 变量的命名规范
- 数据类型
- 数据形式
- 数据分类
- Java中的数据类型
- 面试题
- 运算符
- 赋值运算符
- 算数运算符
- 比较运算符
- 逻辑运算符
- 三目运算符
- 选择结构
- 顺序结构
- 判断结构
- Switch 选择结构
- 循环结构
- for循环
- 循环流程（1243- 243-243）
- whil循环
- 循环流程（ 1234-234-234 ...）
- do-while循环
- 关键字“break”
- 执行流程
- 关键字continue
- 执行流程
- break与continue区别
- 数组
- 数组的的定义
- 数组的声明
- 常见的错误
- 数组的遍历
- Arrays的使用（数组的工具类）
- 求最大最小值
- 数组元素的位移
- 冒泡排序
- 方法与方法重载
- 方法的定义
- 方法的格式
- 注意事项：
- 四种方法
- 方法的调用
- 基本和引用数据类型作为方法的参数
- 构造方法
- 方法重载
- 成员变量和局部变量
- 区别
- Java面向对象——封装
- 面向对象
- 封装（面向对象三大特征之一）
- 封装使用的步骤
- 包
- 修饰符
- 访问修饰符
- 非访问修饰符
- 继承
- 抽象类
- 方法重写
- 接口（Interface）
- 接口和类的关系
- 接口和抽象类的区别
- 多态
- 多态存在的三个必要条件
- 多态的使用环境
- 异常
- 异常的分类
- 解决异常
- 集合
- ArrayList
- ArrayList格式：
- ArrayList和LinkedList的区别
- HashSet
- for 和 foreach的区别
- HashSet和HashTable的区别
- HashMap
- jdk8 HashMap底层是
- 泛型
- API
- Object类中的方法
- equals 和 == 的区别
- 常用方法
- String
- 构造方法
- 常用方法
- String类的型转换功能
- StringBuffer
- 常用方法
- String和StringBuffer的区别
- 包装
- Character常用方法
- MATH 常用方法
- Date
- 构造方法
- 时间化格式
- Caleandar
- 常用方法
- I/o 流
- FILE
- 常用方法
- 字节输出/输入流
- 文件复制
- 字符输出输入流
计算机内存
内存的作用
内存的作用主要是用来平衡CPU的处理速度和硬盘的读取速度。一块正常的机械硬盘连续读取速度是100M/s。而CPU的处理速度远远超过这个速度。所以如果没有内存的参与，可能会产生硬盘全力读取，CPU却一直空闲的状态。
如何使用内存
- 声明
- 由于堆的特性，我们在使用内存时需要先向内存堆申请一块空间，这块空间的申请必须注明数据类型
- 标识
- 由于栈的特性，我们需要首先定义一个标识符，表示我们通过这个标识去寻找这块空间
- 赋值
- 内存堆的使用必须有意义，无效的内存堆空间（null）是一种浪费，不被内存所认可，所以必须申请空间后进行赋值
- 使用
- 前三步已经完成了对内存的使用，接下来就是通过标识符来使用它
要存储不同的数据，必须创建对应类型的变量！
具体要使用哪个数据类型，必须大家通过现实需求进行分析！
变量
内存中的一个存储区域，该区域有数据类型、名称和存储的值。
使用变量
- 整数型
int num = 10;System.out.println(num);
- 字符串型
String str = “欣知”;System.out.println(str)
- 双精度浮点型
double[] nums = double[5];System.out.println(nums);
变量的命名规范
1.变量一般用英文单词表示，首字母小写，遵循驼峰命名规范（变量的名称可以包含 字母、数字、下划线、美元符号，但不能以数字开头）。
2. 不能用java的关键字做变量名，idea里面有颜色的一般都是关键字 (变量的名称不能是Java中的关键字和保留字，但可以包含关键字和保留字。)
3. 变量的名称是严格区分大小写的。
4. 变量的名称尽量做到见名知意。
Java中常见的关键字
数据类型
数据形式
计算机是个“傻子”，它根本不认识任何的数据，但我们通常希望计算机能帮助我们记录数据。而计算机是通电运行的，所以理所当然我们用电流来表达数据。通常情况下，在计算机大部分硬件中，通电表示1，断电表示0。这样就形成了大量的01组合，也就产生了数据。
数据分类
计算机有很多数据类型，为不同类型的数据所准备，也就是说不同类型的数据存放在内存所对应类型的空间中，不同类型的数据对应使用不同的方式进行处理。
Java中的数据类型
基本数据类型：整数（byte、short、int、long）
小数（float、double）
引用数据类型：类（class）
接口（interface）
数组（array）
# 存储信息
| 类型 | 占用空间 | 取值范围 | 默认值 |
|---|---|---|---|
| byte | 1字节 | -128~127 | 0 |
| short | 2字节 | -215~215-1 | 0 |
| int | 4字节 | -231~231-1 | 0 |
| long | 8字节 | -263~263-1 | 0L |
| float | 4字节 | -3.403E38~3.403E38 | 0.0F |
| double | 8字节 | -1.798E308~1.798E308 | 0.0D |
| char | 2字节 | 0~65535 | \u000 |
| 类型 | 取值范围 |
|---|---|
| boolean | true、false |
- 取值范围
public static void main(String[] args) {//byte -2**7~2**7-1byte num1 = 127;// short 16位 -2**15~2**15-1short num2 = 32768-1;// int 32位 -2**31~2**31-1int num3 = 2147483647;// long 64位 -2**63~2**63-1long num4 = 2147483648L;// float 4字节float f = 12.33F;// double 8字节double d = 32.33D;// char 2字节 字符，单引号，里面只能有一个字符 好几个字符组成字符串char c = '韩';// boolean 1字节 true falseboolean b = false;
- 八大基本数据类型
- 四种整数类型(byte、short、int、long)
- 两种浮点数类型(float、double)
- 一种字符类型(char)
- 一种布尔类型(boolean)：true 真 和 false 假。
面试题
- 变量是如何在内存中存储的？
申请空间
标识符
赋值
- int a = 1;在内存中发生了什么变化？
堆内int空间动态分配
栈内标识符a
赋值1
- Java中的数据类型有哪些?
八大基本数据类型
引用数据类型
运算符
赋值运算符
- “=”就是赋值运算符，目的是将=右边的数据，赋值给=左边的空间
- "=“右边永远都是数据或可以得到数据的表达式；”="左边永远都是一块可以存放对应数据类型的空间
int a = 100;System.out.println(a);
算数运算符
+、-、、/、%、++、–、+=、-=、=、/=、%=
- +、-、*、/、%
在编程语言中，除法运算被拆分成了两部分，求商和求余数。
/要用来求商，%用来求余数。
public static void main(String[] args) {int num1 = 10;int num2 = 3;System.out.println(num1+num2);System.out.println(num1-num2);System.out.println(num1*num2);System.out.println(num1/num2);System.out.println(num1%num2);System.out.println(1%3);
- ++ – 自身增加/减少1
如果一行代码里面只用++或者–，那么无论++在前还是在后，结果都是一样的。
如果一行代码里面既有++又有输出语句，那么++在前，先自增1，再输出；++在后，先输出，再自增1。
public static void main(String[] args) {int num = 10;
// num++;
// ++num;
// System.out.println(num++);
// System.out.println(num);System.out.println(++num);System.out.println(num);
- +=、-=、*=、/=、%=
public static void main(String[] args) {// a += b; // a = a + b;// a -= b; // a = a - b;// a *= b; // a = a * b;// a /= b; // a = a / b;// a %= b; // a = a % b;int a = 10;a*=5; // a = a * 5;System.out.println(a);}
比较运算符
<、>、>=、<=、==、!=、equals
比较运算符：用于比较两个数据的关系，比较的结果是一个boolean类型。
<、>、>=、<=、==、!=： 用于比较基本数据类型的值。一般用来比较数字
equals：用于比较引用数据类型的值,一般用来比较字符串。
public static void main(String[] args) {int a = 100;int b = 200;boolean b1 = a > b;System.out.println(b1);boolean b2 = a < b;System.out.println(b2);boolean b3 = a >= b; // a > b 或者 a == bSystem.out.println(b3);boolean b4 = a <= b; // a < b 或者 a == bSystem.out.println(b4);boolean b5 = a == b;System.out.println(b5);System.out.println(100==100);String str1 = "abcd";String str2 = "abc";System.out.println(str1.equals(str2));}
逻辑运算符
&、|、！、&&、||
- 逻辑运算符：一般用于比较boolean类型，结果也是boolean类型。
- & && 与 并且 两个条件同时满足 两个同时为真才为真，否则为假。
- | || 或 或者 两个条件满足一个即可
- ! 非 取反
public static void main(String[] args) {boolean b1 = true;boolean b2 = false;boolean bb1 = b1 && b2;System.out.println(bb1);boolean bb2 = b1 || b2;System.out.println(bb2);System.out.println(!b1);
三目运算符
格式：变量 = 条件表达式?结果1：结果2
- 条件表达式条件成立 变量 = 结果1
- 条件表达式条件不成立 变量 = 结果2
public static void main(String[] args) {int a = 100;int b = 100;String s = a > b ? "a大" : "b大";System.out.println(s);
选择结构
顺序结构
所谓顺序结构，其实就是按照代码原本应该的方式进行执行。
public static void main(String[] args) {int num = 1;System.out.println(num++);System.out.println(num);System.out.println(++num);}
判断结构
If ; if…else… ; else… if
- if(条件表达式){
代码块1…
}else{
代码块2…
}
else: 否则的意思。也就是条件表达式不成立，代码块2要执行
public static void main(String[] args) {System.out.println("=========背景=================");System.out.println("今天风和日丽，旦哥把玩着手串路过小马村，看到了路边有一个卖白菜的小女孩");System.out.println("旦哥说：小妹妹这个白菜好白呀，多少钱一斤？");System.out.println("小姑娘：一块钱一斤");System.out.println("旦哥说：能不能便宜9毛钱？");Scanner scanner = new Scanner(System.in);String talk = scanner.next();System.out.println("小姑娘说："+talk);if("不行".equals(talk)){System.out.println("旦哥骂骂咧咧的走开了");}else {System.out.println("旦哥拱着一颗大白菜回家了");}System.out.println("今天又是有意义的一天啊！");}
}
if(条件1){
代码块1…
}else if(条件2){
代码块2…
}else if(条件3)
代码块3…
}else if(条件4)
代码块4…
}else{
代码块5…
}
if 条件1不成立，往下走
判断条件2，如果条件2成立，执行代码块2，不成立，往下走
判断条件3，如果条件3成立，执行代码块3，不成立，往下走
判断条件4，如果条件4成立，执行代码块4，不成立，往下走
上面的条件都不成立的话，执行代码块5注意事项：但凡有一个成立了，就不往下判断了。
public static void main(String[] args) {/*** 王三蛋在欣知软件开发公司工作一年了，准备买套房子，* 如果他有500万存款，他想买个200平米的大房子；* 如果他有300万存款，他想买个150平米的房子；* 如果他有100万存款，他想买个100平米的房子；* 如果他有10万存款，他想买个厕所；* 否则，就继续卖命工作。*/System.out.println("===========三蛋买房记===========");System.out.println("三蛋工作了一年，有不少存款，准备买房了，打开手机银行APP查询余额：");Scanner scanner = new Scanner(System.in);int money = scanner.nextInt();System.out.println("您的余额是：" + money+"万");if(money >= 500) {System.out.println("三蛋买了200平米的大房子,赠送两个女仆");} else if (money>=300) {System.out.println("三蛋买了150平米的房子,赠送两个白菜");} else if (money>=100) {System.out.println("三蛋买了100平米的房子,赠送高清美女照片");} else if (money>=10) {System.out.println("三蛋买了厕所,赠送一张厕所纸");}else {System.out.println("三蛋继续卖命工作");}System.out.println("今天又是有意义的一天啊！");}
}
Switch 选择结构
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
- switch ：开关
- case：情况
- 流程： 变量挨个和case后面的值进行比较，如果相同，就执行对应的语句体，然后遇到break，就结束switch语句。
- break: 打断、中断，用于结束switch语句。
- default：默认，当所有的case都不满足的时候，就执行default后面的语句体。 和if语句中的else一样。
使用switch的注意事项：
1.case后面只能是常量，不能是变量，而且，多个case后面的值不能相同。
2.default可以省略。但一般不建议，除非结果是可以预计且不会发生变化的。
3.break可以省略，一般不建议。
4.default的位置可以出现在switch语句任意位置。
5.switch语句的结束条件必定是遇到break或已经执行到最末尾
- if和switch的区别：
1. if语句可以判断范围，switch语句只能判断具体的值。
2. if语句可以判断多个条件，switch语句只能判断一个条件。 and or
3. if语句的效率低，switch语句的效率高。
循环结构
for循环
for(声明循环变量;循环条件;迭代){
被循环的代码块
}
- 声明循环变量：声名一个变量
- 循环条件： 一个布尔表达式，如果为true，继续循环，如果为false，结束循环 循环能否继续的判断条件
- 迭代： 循环变量的变化
- 代码块： 被循环的代码
循环流程（1243- 243-243）
1 声明循环变量
2 判断循环条件
3 如果为true，执行代码块
4 执行迭代
5 回到第二步
6 如果为false，结束循环
public static void main(String[] args) {int x = 10;for (int i = 0; i < 5; i++) {System.out.println(x);int a = 10;System.out.println(i);}}
“{}”说明：
{} 表示范围 作用域
{} 里面的代码，只能在 {} 里面使用
{} 外面的变量,我们可以在 {} 里面使用
whil循环
while(循环判断){
被循环的代码块
迭代
}
- 声明循环变量：声名一个变量
- 循环条件： 一个布尔表达式，如果为true，继续循环，如果为false，结束循环 循环能否继续的判断条件
- 迭代： 循环变量的变化
- 代码块： 被循环的代码
循环流程（ 1234-234-234 …）
1 声明循环变量
2 判断循环条件
3 如果为true，执行代码块
4 执行迭代
5 回到第二步
6 如果为false，结束循环
public static void main(String[] args) {int i = 0;int sum = 0;while (i<101){if(i%2==0){System.out.println(i);sum += i;}i++;}System.out.println(i);System.out.println(sum);}
}
do-while循环
do{
被循环的代码块
迭代
}while(循环判断);
- 不管条件是否满足，至少执行一次被循环的代码块
public static void main(String[] args) {System.out.println("===========王者农药夏季限时活动==========");Scanner scanner = new Scanner(System.in);System.out.println("请输入您的金额：");int money = scanner.nextInt();System.out.println("现在开始抽奖，首次免费，再次抽奖需要10元");int num = 1;do {if(num!=1){System.out.println("消费10元，抽奖一次");money-=10;}else {System.out.println("首次免费");}num++;} while (money >= 10);System.out.println("您的余额不足，无法继续抽奖");System.out.println("您一共抽奖了"+(num-1)+"次");}
}
for循环特点
- .结构紧凑
- 书写规范
- 内存使用合理
- 可预知次数的循环
while循环特点
- 语法宽松
- 适应各类循环
- 无法预知次数的循环
do-while循环特点
- 优先执行循环代码
关键字“break”
break是退出循环。当循环中代码执行到break关键字时，会立即退出循环，继续执行循环结构之后的代码。
执行流程
public static void main(String[] args) {for (int i = 1; i <=10 ; i++) {if(i==5){System.out.println("飞飞吃饱了，剩下的苹果分给马宇烁");break;}System.out.println("飞飞吃了第"+i+"个苹果");}System.out.println("又是充满希望的一天");}
关键字continue
continue是跳过本次循环。当代码执行遇到continue时，会将本次循环终止，但是循环结构不退出，继续执行迭代部分并开始下一次循环。
执行流程
public static void main(String[] args) {for (int i = 1; i <=10 ; i++) {if(i==3){System.out.println("飞飞咬了一口，发现苹果有虫子，扔掉这个苹果，吃下一个苹果");continue;}System.out.println("飞飞吃了第"+i+"个苹果");}System.out.println("又是充满希望的一天");}
break与continue区别
| break | continue |
|---|---|
| 退出，终止 | 跳过，继续 |
| 可用在循环和switch | 可用在循环 |
| 退继续之后结构之后的代码 | 不退出循环，进行下一次循环 |
| break之后不能写代码 | 跳continue之后不能写代码 |
数组
数组的的定义
- 内存空间连续的一块区域,用来存储同一种数据类型的多个元素
重点： 1. 连续 同一种数据类型 2. 索引： 从0开始
数组的声明
格式
数据类型[] 数组名 = 初值；数组名其实就是一个变量名
int[] array = new int[5]；[ ]中5就是数组array的长度， 数组的长度一旦给定 就不能修改
定位数组的位置： 数组名[索引] ,比如说第0个元素： 数组名[0]
- 第一种： 一般情况下,当我们不知道数据里面有什么内容的时候,我们会先声明一个数组,然后再去赋值
int[] array = new int[5];array[0] = 1;array[1] = 3;array[2] = 5;array[3] = 6;array[4] = 7;
- 第二种,几乎不用
int[] array2 = new int[]{1,3,5,7,9};
- 第三种, 虽然我们没有明确的指定数组的长度,但是一旦声明了以后,长度就固定了
int[] array3 = {1,3,5,7,9};
常见的错误
- 编译出错，没有写明数组的大小
- 编译出错，数组越界
- 编译出错，创建数组并赋值的方式必须在一条语句中完成
数组的遍历
格式
for(int i=0;i<数组名.length; i++){
System.out.println(数组名[索引] )
}
1 索引：从0开始，到数组的长度-1结束
2 数据的长度： 数组名.length
3 数组名[索引] 定位数组中的元素
public static void main(String[] args) {int[] ages = {18,19,20,21,22,23,24,25,26,27,28,29,30};int length = ages.length;System.out.println(length);System.out.println(ages[1]);for (int i = 0; i < ages.length; i++) {System.out.println("索引："+i+" 值："+ages[i]);}System.out.println(ages);}
Arrays的使用（数组的工具类）
- Arrays.toString(array) 数组的打印 System.out.println(Arrays.toString(array));
int[] ages = {4,2,71,9,5,3,8};// 一般在服务器上打印日志的时候，会使用到这个方法System.out.println(Arrays.toString(ages));
- Arrays.sort(array); 数组的排序：会在原来的数组上修改
int[] ages = {4,2,71,9,5,3,8};// 一般有自然排序的时候，会使用到这个方法Arrays.sort(ages);System.out.println(Arrays.toString(ages));
- Arrays.copyOf(要复制的数组，指定新数组的长度)：会得到一个新的数组
int[] ages = {4,2,71,9,5,3,8};//一般在数组扩容的时候，会使用到这个方法int[] ints = Arrays.copyOf(ages, 10);System.out.println(Arrays.toString(ints));
求最大最小值
public static void main(String[] args) {int[] day={2,334,54,65,34,54,657,87,};int max =day[0];for (int i = 0; i <day.length ; i++) {if (max<day[i]){max=day[i];}}System.out.println(max);int min = day[0];for (int i = 0; i <day.length ; i++) {if(min>day[i]){min=day[i];}}System.out.println(min);
}
数组元素的位移
import java.util.Arrays;public class Demo06 {public static void main(String[] args) {int[] arrays = {1, 2, 3, 4, 5};for (int i = 0; i < arrays.length; i++) {int temp = arrays[0];arrays[0] = arrays[i];arrays[i] = temp;}System.out.println(Arrays.toString(arrays));}
}
冒泡排序
import java.util.Arrays;public class Demo07 {public static void main(String[] args) {int[] arrays = {11, 6, 3, 8, 99, 25, 43};for (int i = 0; i < arrays.length-1; i++) {for (int j = 0; j < arrays.length-1-i; j++) {if(arrays[j]<arrays[j+1]){int temp = arrays[j+1];arrays[j+1] = arrays[j];arrays[j] = temp;}}}System.out.println(Arrays.toString(arrays));}
}
方法与方法重载
方法的定义
- 解决问题的一种方案，他是有很多条java语句组成的
方法的特点：
1 方法执行的时候，可能需要原料。 (原料就是参数)
2方法执行完了以后，可能会给我们一个结果 （结果就是返回值）
3 声明方法，其实就是在定义规则
方法的格式
修饰符 返回值类型 方法名(参数类型 参数名){
…
方法体
…
return 返回值;
}
- 修饰符: public
- 返回值类型:本质就是数据类型
- 方法名:方法的名字(命名规范和变量的一样)小驼峰
- 参数类型:本质就是数据类型
- 参数名:本质就是变量名
- 方法体:就是一些java语句
- return:关键字，结束方法，一般用在返回值前面
- 返回值:方法执行完以后，得到的结果。
注意事项：
- 返回值类型:跟返回值有关系，如果没有返回值，那么返回值类型就是void，然后也不用写return
- 参数类型:跟参数有关系
- 定义方法，其实就是在定义规则。这个在方法调用的时候很关键.
四种方法
- 无参无返回值
public void say(){System.out.println("hello");}public Demo02(){}public static void main(String[] args) {Demo02 demo02 = new Demo02(); // demo02就是对象，本质还是一个变量demo02.say();}
- 无参有返回值（如果方法有返回值，那么这个方法调用的时候，就会有一个结果。这个结果可以赋值给一个变量）
public String grilFriend(){return "小马哥";}public Demo02(){}public static void main(String[] args) {String friend = demo02.grilFriend();System.out.println(friend);}
- 有参无返回值
public void showFriend(String name){System.out.println("老马的对象是："+name);}public Demo02(){}public static void main(String[] args) {demo02.showFriend("小马哥");}
- 有参有返回值
public int add(int a,int b){int c = a + b;return c;}public Demo02(){}public static void main(String[] args) {int add = demo02.add(4, 5);System.out.println(add);}
方法的调用
1.方法想要执行，必须要调用
2.方法是谁执行的? 方法是对象执行的
3.对象是哪里来的?对象是new出来的，new+方法所在的类名 () :
4.对象调用方法: 对象，方法名 (参数)
5.方法执行的本质就是: 方法里的代码跑了一遍。方法每被调用一次， 方法里的代码就执行一次
方法调用的细节
方法调用的时候，到底该怎么使用参数
定义方法，其实就是在定义规则。这个在方法调用的时候很关键。
我们在定义方法的时候，定义好了参数的数据类型，那么调用的时候，必须要和定义的一样。
public String getFriend(int num,String name) {System.out.println(name + "有" + num + "个女朋友");return "泰库拉";}public static void main(String[] args) {Demo03 demo03 = new Demo03();String s = demo03.getFriend(3, "小马哥");System.out.println(s);}
基本和引用数据类型作为方法的参数
- 如果基本数据类型作为方法的参数：其实就是将基本数据类型的值，拷贝了一份副本给了方法，方法中对这个副本的修改，不会影响到原来的值
- 如果引用数据类型作为方法的参数：其实就是将引用数据类型的地址，拷贝了一份副本给了方法，方法中对这个副本的修改，会影响到原来的值
public class Demo04 {//参数是基本数据类型public void pl1(int score) {score += 1;}//参数是引用数据类型public void pl2(Student student) {student.score += 1;}public static void main(String[] args) {int scort = 1;Demo04 demo04 = new Demo04();demo04.pl1(scort);System.out.println(scort);Student student = new Student();student.score = 1;demo04.pl2(student);System.out.println(student.score);}
}
构造方法
语法
无返回值类型
方法名与类名相同
可以指定参数
两种方法
创建对象new + 构造方法
初始化成员变量(给成员变量赋值)
构造
public class Student {// 姓名public String name;// 分数public int score;//无参构造方法public Student(){}//有参构造方法public Student(String name, int score) {this.name = name;this.score = score;}
}
- 运用
public class Demo05 {public static void main(String[] args) {Student student = new Student();student.name = "小马哥";student.score = 100;Student student1 = new Student("小马哥1", 100);System.out.println(student1.name);}
}
方法重载
同一个类中
方法名相同
参数列表不同(参数个数不一样，参数的类型不一样)
与修饰符和返回值无关
注意事项： 构造方法也可以重载
成员变量和局部变量
- 成员变量：不在方法里的变量就是成员变量
- 局部变量：在方法里面的变量就是局部变量(包含参数上的变量）
区别
| 成员变量 | 局部变量 |
|---|---|
| 定义在类中，整个类中都可以访问 | 定义在方法中，只能在方法中使用 |
| 可以不给初始值，因为有默认值 | 必须有初始值否则报错(除了参数) |
| 如果成员变量和局部变量名字一样：成员变量前面可以加this，this代表当前对象 |
|---|
| 我们在方法里面使用变量的时候，如果方法里面有，就用自己的，如果没有就用成员变量的，如果成员变量没有，就报错 |
Java面向对象——封装
面向对象
类的概念
- 类：是一组具有相同属性和行为的事物的集合，本质还是一种数据类型；类是抽象的不占内存
- 属性：事物的静态特征 成员变量
- 行为：事物的动态特征（方法和动作）
对象的概念
- 对象:对象是真实存在的实体，对象是具体的，是类的具体体现（对象就是类的举例）
- 创建对象 new+构造方法（）
- 类是对象的抽象 对其他类在进行抽象就是抽象类
- 抽象 ： 提取事物的共性，忽略事物的特性
封装（面向对象三大特征之一）
概念
- 隐藏对象的属性和实现细节 将我们的成员变量私有化，修饰符为private
- 仅对外提供公共访问式 给我们的成员变量提供公共访问方式。getXXX()；setXXX()
- set属性 () :用来设置属性值的方法
- get属性 () :用来获取属性值的方法
- 既然封装是面向对象的三大特征之一，那么我们在使用的时候，就应该遵循一些规则(我们以后在写成员变量的时候，都要私有化，提供公共访问方式）
public class Car {private String pinpai;private String xinhoa;private int shoujia;private int ziazhong;public Car() {}public Car(String pinpai, String xinhoa, int shoujia, int ziazhong) {this.pinpai = pinpai;this.xinhoa = xinhoa;this.shoujia = shoujia;this.ziazhong = ziazhong;}public String getPinpai() {return pinpai;}public void setPinpai(String pinpai) {this.pinpai = pinpai;}public String getXinhoa() {return xinhoa;}public void setXinhoa(String xinhoa) {this.xinhoa = xinhoa;}public int getShoujia() {return shoujia;}public void setShoujia(int shoujia) {this.shoujia = shoujia;}public int getZiazhong() {return ziazhong;}public void setZiazhong(int ziazhong) {this.ziazhong = ziazhong;}@Overridepublic String toString() {return "Car{" +"pinpai='" + pinpai + '\'' +", xinhoa='" + xinhoa + '\'' +", shoujia=" + shoujia +", ziazhong=" + ziazhong +'}';}
}
public class Test04 {public static void main(String[] args) {Car car = new Car();car.setPinpai("大奔");car.setXinhoa("奔驰E300");car.setShoujia(500000);car.setZiazhong(100000);System.out.println(car);}
}
封装使用的步骤
1 成员变量私有化 private
2提供公共访问方式 getXXX()setXXX()
访问修饰符
1 private: 私有的，只能在本类中访问
2 default: 默认的，只能在本包中访问
3 prqtected: 受保护的，只能在本包中访问，子类可以访问
4 public: 公共的，都可以访问
包
- “包”本质就是一个文件夹，用来管理我们的类的，我们的类都要放在包中。
- 包名：一般都是我们公司的域名倒着写
修饰符
访问修饰符
| 修饰符 | 作用 |
|---|---|
| private | 私有的，只能在本类中访问 |
| default | 默认的，只能在本包中访问 (同一个文件夹中) |
| protected | 受保护的，只能在本包中访问，子类可以访问 |
| public | 公共的，都可以访问 |
非访问修饰符
| 修饰符 | 作用 |
|---|---|
| static | 静态的,修饰成员变量和成员方法的。static修饰的成员变量和成员方法，不能直接调用非静态的成员变量和成员方法 |
| final | 最终的，修饰类，修饰成员变量，修饰成员方法 |
| abstract | 修饰符，用来创建抽象类和抽象方法 |
| synchronized | 修饰符，主要用于线程的编程，synchronized 关键字声明的方法同一时间只能被一个线程访问。 |
| volatile | olatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 |
继承
含义：子类继承父类，可以直接使用父类的属性和方法（主要使用方法）
父类：有时也别叫做超类、基类
关键字：extends
继承：类和类之间的关系
一般什么时候用继承：一般一个小的类和一个大的类之间这样使用；比如：Animal Dog Cat
好处：减少代码的沉余
- 特点
1.子类可以继承父类非prviate 属性和方法
2.子类可以有自己特有的属性和方法
3.Java类的继承是单类继承，但是可以多重继承
4.子类可以重写父类 - 单类继承
- 多类继承（3也可以用1的方法）（student是孙子类 ）
Super与this 关键字
子类的构造方法里，默认的添加了super（），如果手动添加，必须放在第一句
- Super与this 的区别
1.this代表本类对象的引用（this理解为一个代词，就是创建了一个对象，new的那个对象）
例子：我吃桃子(谁吃桃子，这个我就是谁)
2.Super代表父类对象
3.属性和方法都是对象调用的，那么this和super都可以调用属性和方法
同一个类里面 静态>代码块>构造方法
子父类里面:父类静态>子类静态>父类代码块>父类构造方法> 子类代码块> 子类构造方法
类创建要比对象早,static是属于类的，不属于对象。
在静态的里面不要调用非静态的，也不要用this和super
抽象类
概念：被abstract修饰的类叫抽象类
把一些类的共同特征抽取出来，放到一个类中，这个类就叫抽象类。
- 抽象方法：被abstract修饰的类叫抽象方法
抽象方法没有方法体 - 特点
抽象类可以有构造方法，但是不能创建对象，抽象类的构造方法是给成员变量初始化的
抽象类可以有普通成员变量，也可以有静态成员变量
抽象类里面有抽象方法，普通类里面不能有抽象方法
普通类继承了抽象类，必须重写抽象类中的抽象方法
抽象类也可以有普通的方法
注意：抽象类天生就是当爹的
方法重写
1.在继承或者实现关系
2.方法名参数列表返回值必须一致
3.子类的访问权限必须大于等于父类的访问权限（一般为public）
4.子类抛出的异常必须雄小于等于父类抛出的异常
- 为什么要有方法重写？
当父类不知道子类的方法到底怎么执行的时候，就需要把这个方法定义成抽象方法，让子类去重写这个方法。
子类继承了父类以后，子类就拥有了父类的方法。但是这个方法不适合子类，就需要子类重写这个方法。
接口（Interface）
概念
1.主要定义规范（抽象方法，经常省略public abstract）
2.和类一样也是一种引用数据类型
3.接口中的成员变量都是常量。 public，static，final 可以省略不写（这个在开发中用的很少）
4.接口是用来被实现的，而且一个类可以实现多个接口。Implements（类和接口的关系）
public interface A {int a = 100;int b = 200;void eat();int add(int a, int b);
接口和类的关系
1.接口不能有构造方法。所以也不能实例化对象
2.接口里面不能有普通方法，只能有抽象方法。
3.接口是不能被类继承的(但是能被接口承)，但是可以被类实现
- java是单继承的吗?
java中类和类之间是单继承的，但是接口和接口之间是多继承的。
接口和抽象类的区别
| 抽象类 | 接口 |
|---|---|
| 抽象类中的方法可以有方法体 | 接口中的方法没有构造方法 |
| 成员变量可以是各种类型 | 成员变量只能是 public static final 类型 |
| 不能含有静态代码块以及静态方法(用 static 修饰的方法) | 可以有静态代码块和静态方法 |
| 一个类只能继承一个抽象类 | 一个类却可以实现多个接口 |
- 什么时候用抽象类？什么时候用接口？
1 抽象类: 一般情况下，父类和子类之间有共同的特征，我们使用抽象类
public class Test {public static void main(String[] args) {GlassDoor glassDoor = new GlassDoor();glassDoor.open();glassDoor.lock();glassDoor.close();IronDoor ironDoor = new IronDoor();ironDoor.open();ironDoor.close();ironDoor.lock();ironDoor.alarm();}
2.接口:一般情况下，这个类的特征不是共有的，我们使用接口
public interface IUser {/*** 登录* @param username 用户名* @param password 密码*/void login(String username,String password);/*** 注册* @param username 用户名* @param password 密码*/void register(String username,String password);
}
public class User implements IUser{@Overridepublic void login(String username, String password) {}@Overridepublic void register(String username, String password) {}
}
多态
概念
同一个对象，在不同时刻表现出来的不同形态
多态的前提：继承或实现
多态存在的三个必要条件
1.要有继承或者实现关系
2.要有方法重写
3.要有父类引用指向子类对象 引用就是变量，子类对象就是值（向上转型）
- 注意事项
- 子类重写了父类的方法以后，执行的是自己的方法。
- 子类没有，父类有的方法，子类可以通过继承直接使用
- 子类有，父类没有，调用的时候直接报错
解释：子类就是父类范围的一种
人–>父类
学生–>子类
学生就是人 人类 人=new 学生（）；
不能说人就是学生
向上转型与向下转型
向上转型: 子类往上走一步，变成父类类型。
向下转型:父类往下走一步，变成子类类型。
1 强制类型转换，可能会出现类型转换异常
2向下转型之前，必须先向上转型
3 为了避免类型转换异常，可以使用instanceof关键字进行判断
- instanceof对象 instanceof 类型判断对象是否是这个类型
多态的使用环境
概念
方法的形参是父类类型，实参可以是子类类型
形参:方法声明时，方法小括号里的参数
实参:方法调用时，方法小括号里的参数
- 好处：提高了代码的扩展性
异常
概念
代码运行时出现的错误
问题：程序终止行动（如果代码出现异常，那么后面的代码就不运行）
异常的分类
编译时异常:代码还没运行，就出现了问题
SQLException: 作数据库时查询表可能发生的异常
- IOException: 操作文件时发生的异常
- FileNotFoundException: 操作不存在文件时发生的异常
- CLassNotFoundException: 加载类而类不存在时发生的异常
- EOFException: 操作文件到文件未尾发生异常ILLegaLArguementException: 参数异常
运行时异常:代码在正常的运行过程中出现的问题
NulLPointerException: 空指针异常，当应用程序试图在需要对象的地方出现nuLL时抛出该异常
ArithmeticException:数学运算异常，当出现异常的运算条件时抛出此异常
ArrayIndex0utOfBoundsException:数组下标越界异常，用非法索引访问数组时抛出的异常
- CLassCastException : 类型转换异常，当试图将对象强制转换为不是实例的子类时抛出该异常
- NumberFormatException:数字格式不正确异常，当应用程序试图将字符审转换成一种数值类型，但该字符串不能转换为适当格式时抛出该异常
解决异常
- Try 捕获异常
- catch 处理异常
- finally 不管有没有异常都会执行，一般用来释放资源
如果try中有多个异常，那么catch也要有多个，每个catch只能捕获一个异常
Catch里面的异常从上到下，从小到大，从子到父
- throws/throw 关键字
- throw 生成一个异常
- throws 抛出一个异常谁调用我，我就抛给谁，异常最终抛给了JVM（很少用）
集合
概念：同一类事物放在一起组成了集合（引用数据类型，这是和数组最大的区别），集合当中所有的东西统称为元素。
- 集合=Collection（接口） 父类是Iterable（接口：功能是集合的迭代编历）
集合的分类
1.List(接口)：有序可以重复 常见的实现类：ArrayList（数组实现）LinkedList(链表实现)2.Set（接口）:无序不可以重复 常见的实现类：HashSet（哈希表实现） TreeSet（二叉树实现）
ArrayList
概念
ArrayList<0bject>：<>放的就是泛型，放我们指定的数据类型；指的就是集合里面放入的数据类型 注：object是所有类的父类！
泛型的好处:省去了从集合中取出数据时的强制类型转换。
加了泛型，就会要求我们放入数据的时候，智能放入该数据类型的数据，那么取出来的也是这种数据类型。
public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();}
- ArrayList：实现了List 接口（List 继承了Collection接口）
- 一个类实现了一个接口，那么我们就要重写这个接口里的(抽象)方法 ，也就是说，接口里的方法是大家都有的。
ArrayList格式：
1.底层是数组（Object[]）
2.ArrayList 元素个数 size （）方法
3.增（添加) : add(元素）数组的长度和size不是一回事,如果size（）小于数组长度，直接将元素放入到数据里面。
public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();ArrayList<String> list = new ArrayList<>(10);list.add("张三");list.add("李四");list.add("王五");list.add("张三");System.out.println(list);}
4.删(删除): remove(元素): 删除第一次出现的元素；remove(索引): 删除指定索引位置的元素
public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();ArrayList<String> list = new ArrayList<>(10);list.add("张三");list.add("李四");list.add("王五");list.add("张三");list.remove(1);System.out.println(list);}
5.改(修改) :set(索引，元素)
public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();ArrayList<String> list = new ArrayList<>(10);list.add("张三");list.add("李四");list.add("王五");list.add("张三");String ss = list.set(0, "赵六");System.out.println("原来0索引的元素是：" + ss);}
6.查(查询) :get(索列)
public static void main(String[] args) {ArrayList<String> list1 = new ArrayList<>();ArrayList<String> list = new ArrayList<>(10);list.add("张三");list.add("李四");list.add("王五");list.add("张三");for (String s : list) {System.out.println(s);}}
ArrayList和LinkedList的区别
| ArrayList | LinkedList |
|---|---|
| 数组 （底层数据结构不一样） | 链表（底层数据结构不一样） |
| 查询快 | 查询慢 |
| 增删慢 | 增删快 |
HashSet
public static void main(String[] args) {
HashSet set = new HashSet<>();}
- 功能
- 增强for循环【for(数据类型 变量: 集合名称){使用变量 }】
for (Integer i : set) {System.out.println(i);}
- 去重功能(构造方法里面可以放集合，思路就是先把list转成set去重，然后再转成list)
- 只有增，没有改查
public static void main(String[] args) {HashSet<Integer> set = new HashSet<>();set.add(1);set.add(1);set.add(2);set.add(3);System.out.println(set);set.remove(1);System.out.println(set);set.clear();System.out.println(set);
}
- 去重，HashSet开发时候用的比较少，一般集合都是用ArrayList
- 在某些场合下也需要ArrayList去重，可以使用HashSet
ArrayList<String> names = new ArrayList<>();names.add("张三");names.add("李四");names.add("张三");names.add("王五");names.add("赵六");// 1、创建一个HashSet 2、将ArrayList中的元素全部放入HashSet中 3、将HashSet中的元素全部放入ArrayList中HashSet<String> set1 = new HashSet<>(names);names = new ArrayList<>(set1);System.out.println(names);
for 和 foreach的区别
| for | Foreach |
|---|---|
| 可以操作索引 | 不可以操作索引 |
| 语法结构相对复杂 | 语法结构相对简单 |
HashSet和HashTable的区别
| HashSet | HashTable |
|---|---|
| 不安全 | 安全 |
| 效率高 | 效率低 |
| 允许nuLL值 | 不允许nulL值 |
HashMap
概念 ：双利集合；
new HashMap<K，V> K 键 V 值键值对
键是唯一的，值可以重复
- 增
public static void main(String[] args) {HashMap<String, Integer> map = new HashMap<>();map.put("老马", 18);map.put("小马", 28);System.out.println(map);}
- 改（和增加的语法一样，如果键存在就是修改，如果键不存在就是增加）
public static void main(String[] args) {HashMap<String, Integer> map = new HashMap<>();map.put("老马", 18);map.put("小马", 28);map.put("老马", 38);System.out.println(map);}
- 查
public static void main(String[] args) {HashMap<String, Integer> map = new HashMap<>();map.put("老马", 18);map.put("小马", 28);map.put("老马", 38);Integer age = map.get("老马");System.out.println(age);}
- 删
public static void main(String[] args) {HashMap<String, Integer> map = new HashMap<>();map.put("老马", 18);map.put("小马", 28);map.put("老马", 38);map.remove("老马");System.out.println(map);
jdk8 HashMap底层是
- :数组+链表+红黑树
- HashMap负载因子:0.75
- 链表的长度超过8，链表就会转换成红黑树。如果红黑树的长度小于6，红黑树就会转换成链表。
- HashMap初始长度16
泛型
- 集合里面放数据的时候，可以指定数据类型，这样从集合里面拿出数据的时候就不用做类型转换
API
Object
概念所有类的父类 ；0bject类中的方法都可以被子类使用
Object类中的方法
1.getClass:返回对象的字节码文件对象
2.hashCode:返回对象的哈希码值
3.equals: 比较两个对象是否相等
4.toString: getClass().getName() +“@” + Integer.toHexString(hashCode());类的全路径名 + @ + 对家的哈希妈值的十六进制,如果我们想按照自己的想法输出对象的信息，我们就需要重写toString 方法
equals 和 == 的区别
| 区别 | |
|---|---|
| equals | 底层的代码就是==，只能比较引用数据类型 |
| == | 可以比较基本数据类型和引用数据类型,比较基本数据类型的时候比较的是值，比较引用数据类型的时候比较的是地址值 |
- 全限定符名: 包名.类名
常用方法
| 方法名 | 作用 | 返回值 |
|---|---|---|
| hashCode() | 获取对象hash值 | int |
| toString() | 将对象信息变为字符串返回 | String |
| equals(Object obj) | 判断两个内存地址是否一样 | boolean |
| getClass() | 获取类名 | Object |
String
1 被final修饰的类，不能被继承
2 字符串存在于常量池中 如果new STring （）会在堆内存中开辟空间，如果直接赋值的话，会在常量池中开辟空间
构造方法
- public String()
- public String(byte[] bytes)
- public String(byte[]bytes,int offset,int length)
- public String(char[] value)
- public String(char[] value,int offset,int count)
- public String(String original)
常用方法
| 方法名 | 作用 | 返回值 |
|---|---|---|
| isEmpty() | 判断是否为空 | boolean |
| length() | 取到该String的长度 | int |
| equals(Object obj) | 判断两个字符串是否相等 | boolean |
| equalsIgnoreCase(String as) | 不区分大小写比较 | Object |
| charAt(int index) | 返回该下标的char | char |
| substring(int start) | 截取字符串下标从start开始 | String |
| substring(int start,int end) | 截取区间字符串从start开始到end结束（包头不包尾 | String |
| replace(char old,char new) | 替换字符串 | String |
| trim() | 去掉字母首尾空格 | String |
| indexOf() | 寻找某个字符串在目标字符串的位置 | int |
String类的型转换功能
| 方法名 | 作用 | 返回值 |
|---|---|---|
| getBytes() | 转换成bytes型数组 | byte[ ] |
| toCharArray() | 转换成char型数组 | char[ ] |
| String valueOf(char[] chs) | 将入参类型转换为String | String |
| toLowerCase() | 将所有英文字母转换为小写字母 | String |
| toUpperCase() | 将所有英文字母转换为大写字母 | String |
| concat(String str) | 将指定字符串连接到此字符串的结尾 | String |
StringBuffer
概念 StringBuffer是用来解决String更改字符串造成的时间浪费和空间浪费的
常用方法
- append(String str) 追加字符串
StringBuffer user = new StringBuffer("小明");user.append("是个大帅哥");user.insert(2,"哥");System.out.println(user);}
- deleteCharAt(int index) 删除下标处的字符
public static void main(String[] args) {StringBuffer user = new StringBuffer("小明");user.append("是个大帅哥");user.insert(2,"哥");System.out.println(user);user.deleteCharAt(2);System.out.println(user);user.delete(5, 6);System.out.println(user);}
- replace(int start,int end,String str) 替换区间字符
public static void main(String[] args) {StringBuffer user = new StringBuffer("小明");user.append("是个大帅哥");user.insert(2,"哥");System.out.println(user);user.replace(5, 8, "大渣男");//[5,8)System.out.println(user);
}
- substring(int start,int end) 截取区间字符串从start开始到end结束（包头不包尾）
public static void main(String[] args) {StringBuffer user = new StringBuffer("小明");user.append("是个大帅哥");user.insert(2,"哥");System.out.println(user);String substring = user.substring(5, 8);System.out.println(substring)
}
- reverse() 反转字符串
public static void main(String[] args) {StringBuffer user = new StringBuffer("小明");user.append("是个大帅哥");user.insert(2,"哥");System.out.println(user);user.reverse();System.out.println(user);
}
- split() 拆分字符串
public static void main(String[] args) {String ss = "157-3525-6010";String[] split = ss.split("-");System.out.println(Arrays.toString(split));}
String和StringBuffer的区别
- String类的内容是不可改变的。能改变的只是其内存指向。
- String对象不可修改指的是对象本身不可修改，而不是引用不可修改。
- StringBuffer类的对象内容是可以修改的。
- String可以直接通过赋值的方式实现对象实例化，而StringBuffer只能通过构造方法的方式对象实例化。
- StringBuffer在处理字符串的时候，不会生成新的对象。从内存这个角度来说，StringBuffer要比String更好。
- StringBuffer是线程安全的，速度慢。 StringBuilder是线程不安全的，不能同步访问，执行速度快
包装
基本数据类型： 是没有方法的，但是可以通过包装类来实现方法的调用
写法上只有
int Integer
char Character
剩下的都是首字母大写
- 装箱：穿装备（变强） 基本数据类型—>包装类
- 拆箱：脱装备（变弱） 包装类—>基本数据类型
[ ] 常用方法
1 intValue() 转换成int
2 parseInt(String s) String转换成int
public static void main(String[] args) {int a = 1;Integer b = a;int c = b;int i = b.intValue();Integer r = Integer.valueOf("123");// 字符串必须是数字，否则报错System.out.println(r);int i1 = Integer.parseInt("12");
}
Character常用方法
- isUpperCase(char ch) 判断指定字符是否为大写字母
public static void main(String[] args) {boolean a1 = Character.isUpperCase('A');System.out.println(a1);
}
- isLowerCase(char ch) 判断指定字符是否为小写字母
public static void main(String[] args) {boolean a2 = Character.isLowerCase('a');System.out.println(a2)}
3 isDigit(char ch) 如果字符串中只含有数字则返回True
public static void main(String[] args) {boolean a3 = Character.isDigit('A');System.out.println(a3);
}
- toLowerCase(char ch) 将大写字符转换为小写
public static void main(String[] args) {char a4 = Character.toLowerCase('A');System.out.println(a4);
}
MATH 常用方法
- abs(int a) 取绝对值
public static void main(String[] args) {int a = -100;System.out.println(Math.abs(a));
- ceil(double a) 返回最小值
public static void main(String[] args) {double b = 3.56;double ceil = Math.ceil(b);
- floor(double a) 返回最大值
public static void main(String[] args) {double b = 3.56;double floor = Math.floor(b);System.out.println(floor);
- max(int a,int b) 取最大值
public static void main(String[] args) {int max = Math.max(100, 200);System.out.println(max);
- round(float a) 四舍五入成整数
public static void main(String[] args) {double b = 3.56;long round = Math.round(b);System.out.println(round)
- random() 随机数
public static void main(String[] args) {double random = Math.random(); //0-1之间的小数int aa = (int)(random * 100);System.out.println(aa);System.out.println(Math.sqrt(9));}
Date
构造方法
- public Date()
- public Date (long date)
- public Date(String s)
- public Date(int year,int month,int date)
- public Date(int year,int month,int date,int hrs,int min)
时间化格式
/** 输出格式: 2016-10-26 4:48:11*/
System.out.println((new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date()));
/** 输出格式: 2016-10-26 16:48:11 */
System.out.println((new java.text.SimpleDateFormat("yyyy-M-d H:mm:ss")).format(new Date()));
/**这里需要注意的就是24时和12时的显示正则，H大写为24时计时法，h小写为12时计时法，两个h时，即hh，当为个位数时间时前面自动补0即下午4点显示04*/
- 案例
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;public class Life {public static void main(String[] args) throws ParseException {Scanner user = new Scanner(System.in);System.out.println("请输入你的出生年月：");String bornDate= user.next();//获取出生日期SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd");//字符串转换成date类型Date d = s.parse(bornDate);Date now =new Date();//获取当前时间long nowTime = now.getTime();//将当前时间转换成毫秒long bornTime = d.getTime();//将出生日期转换成毫秒long time = nowTime-bornTime;System.out.println(time/1000);}
}
Caleandar
概念：Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法
常用方法
- getInstance() 获取日期
public static void main(String[] args) {Calendar instance = Calendar.getInstance();System.out.println(instance);
}
I/o 流
I 输入 （程序外部到内部）硬盘到内存
o 输出 程序内部到外部（内存到硬盘）
流：需要一个一个处理数据，前提有输出输入
特性： 极其消耗性能
FILE
文件的意思(文件和文件夹)，对计算机来说，文件就是指定盘符下的文件或者文件夹
构造方法：构造方法:public File(String pathname) pathname: 文件的路径
常用方法
- createNewFile() 创建名称的空文件，不创建文件夹
public static void main(String[] args) throws IOException {File file = new File("E:\\文件");boolean a = file.createNewFile();System.out.println(a);}
- isFile() 判断是否是文件
public static void main(String[] args) throws IOException {File file = new File("E:\\文件");boolean a = file.createNewFile();System.out.println(a);File file1 = new File("e:\\xinzhi(shixi)\\lainxi\\Newxaingmu\\xiangmu01");boolean b = file.isFile();System.out.println(b);boolean b1 = file.isDirectory();System.out.println(b1);}
- isDirectory() 判断是否是目录
public static void main(String[] args) throws IOException {File file = new File("E:\\文件");boolean a = file.createNewFile();System.out.println(a);File file1 = new File("e:\\xinzhi(shixi)\\lainxi\\Newxaingmu\\xiangmu01");boolean b = file.isFile();System.out.println(b);boolean b1 = file.isDirectory();System.out.println(b1);}
- getAbsolutePath() 返回此对象表示的文件的绝对路径名
public static void main(String[] args) throws IOException {File file = new File("E:\\文件");File file1 = new File("e:\\xinzhi(shixi)\\lainxi\\Newxaingmu\\xiangmu01");File b2 = file.getAbsoluteFile();System.out.println(b2);}
- getPath() 返回此对象表示的文件的相对路径名
public static void main(String[] args) throws IOException {File file = new File("E:\\文件");File m= new File("e:\\xinzhi(shixi)\\lainxi\\Newxaingmu\\xiangmu01");String path = m.getPath();System.out.println(path);}
- getName() 返回此对象表示的文件或目录的名称
public static void main(String[] args) throws IOException {File file = new File("E:\\文件");File m= new File("e:\\xinzhi(shixi)\\lainxi\\Newxaingmu\\xiangmu01");String name = m.getName();System.out.println(name);}
- length() 返回文件的长度，单位为字节
public static void main(String[] args) throws IOException {File file = new File("E:\\文件");File m= new File("e:\\xinzhi(shixi)\\lainxi\\Newxaingmu\\xiangmu01");long length = file.length();System.out.println(length);}
- exists() 判断文件或目录是否存在
public static void main(String[] args) throws IOException {File file = new File("E:\\文件");File m= new File("e:\\xinzhi(shixi)\\lainxi\\Newxaingmu\\xiangmu01");boolean exists = m.exists();System.out.println(exists);}
字节输出/输入流
InputStream 输入流(读)读取数据内存
File a = new File("xinzhi.txt"); //定位文件位置InputStream in=new FileInputStream(a); //创建字节输入流连接到文件byte[] b=new byte[521]; //定义一个数组，用来存放读入的数据 byte数组的大小也可以 根据文件大小来定 (int)f.length()int count =0; int temp=0;while((temp=in.read())!=(-1)){ //in.read（）是逐字节读的。当读到文件末尾时候返回-1b[count++]=(byte)temp; //将读到的字节存储到byte数组中 }in.close(); //关闭流System.out.println(new String(b)); //打印读取到的字节
OutputStream 输出流(写)写数据到文件
File amazy = new File("xinzhi.txt"); // 定位文件位置OutputStream out = new FileOutputStream(amazy ); // 创建字节输出流连接到文件String str = "Java历险记"; byte[] b = str.getBytes(); //将数据存入byte数组out.write(b); //写数据 out.close(); //关闭流
文件复制
文件的拷贝： 思路就是从一个磁盘里面读取的时候，写到另外一个磁盘里面。
public class CopyDemo01 {public static void main(String[] args) throws IOException {FileInputStream fis = null;FileOutputStream fos=null;long start = System.currentTimeMillis();try {fis = new FileInputStream("E:\\BaiduNetdiskDownload\\HBuilderX 3.1.22.rar");fos = new FileOutputStream("D:\\hb.rar");byte[] bytes= new byte[1024*1024];int lon = fis.read(bytes);while (lon!=-1){fos.write(bytes,0,lon);lon = fis.read(bytes);}long end = System.currentTimeMillis();System.out.println("花费"+(end-start)+"ms");} catch (FileNotFoundException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);} finally {if (fis!=null){try {fis.close();}catch (IOException a){throw new RuntimeException(a);}}if (fos!=null){fos.close();}}}
}
字符输出输入流
字符流： 字符流的底层还是字节流， 字符流是专门处理文本的
- 字符输入流： FileReader
public static void main(String[] args) {try {FileReader reader = new FileReader("d:\\java.txt");char[] chars = new char[1024];int read = reader.read(chars);System.out.println(read);String s = new String(chars, 0, read);System.out.println(s);} catch (FileNotFoundException e) {throw new RuntimeException(e);} catch (IOException e) {throw new RuntimeException(e);}}
- 字符输出流： FileWriter
public static void main(String[] args) {FileWriter writer = null;try {writer = new FileWriter("d:\\java.txt",true);writer.write("努力称为一名优秀的职场人");writer.flush();} catch (IOException e) {throw new RuntimeException(e);}finally {if(writer!=null){try {writer.close();} catch (IOException e) {throw new RuntimeException(e);}}}}
Java基本语法-高级运用相关推荐
- Java 接口语法_JAVA接口的基本语法
一.接口的概念 在之前学习了抽象类,其中抽象类的抽象方法定义了标准,具体的方法实现交给子类完成,之后再结合多态的特征在一定程度上解决代码的耦合(上节课的参数统一),这需要在继承关系中实现,但是继承存在 ...
- 深入理解java虚拟机 - jvm高级特性与最佳实践(第三版)_JVM虚拟机面试指南：年薪30W以上高薪岗位需求的JVM，你必须要懂！...
JVM的重要性 很多人对于为什么要学JVM这个问题,他们的答案都是:因为面试.无论什么级别的Java从业者,JVM都是进阶时必须迈过的坎.不管是工作还是面试中,JVM都是必考题.如果不懂JVM的话,薪 ...
- Java基础语法（一）
Java 简介 Java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言和Java平台的总称.由James Gosling和同事们共同研发,并在1995年正式 ...
- JAVA学习（三）：Java基础语法（变量、常量、数据类型、运算符与数据类型转换）...
Java基础语法(变量.常量.数据类型.运算符与数据类型转换) 1.变量 Java中.用户能够通过指定数据类型和标识符来声明变量.其基本的语法为: DataType identifier; 或 Dat ...
- Java基本语法和规范
Java基本语法和规范 语言按程序的执行方式分为编译型和解释型两种. 编译型:需要使用专门的编译器,针对特定平台(操作系统)翻译成可被该平台执行的机器码,编译生成的可执行程序可以脱离开发环境在特定平台 ...
- Java基础语法知识你真的都会吗？
第一阶段 JAVA基础知识 第二章 Java基础语法知识 在我们开始讲解程序之前,命名规范是我们不得不提的一个话题,虽说命名本应该是自由的,但是仍然有一定的"潜规则",通过你对命名 ...
- 01.Java基础语法
目录 01.Java基础语法 一,环境搭建 1,Java体系与特点 2,Java跨平台原理 2.1 Java虚拟机(JVM) 2.2 垃圾回收器(GC) 2.3 Java SE组成概念图 2.4 JD ...
- java自动化测试语言高级之Java 8 新特性
java自动化测试语言高级之Java 8 新特性 文章目录 java自动化测试语言高级之Java 8 新特性 Java 8 新特性 Java 8 新特性 Java 8 (又称为 jdk 1.8) 是 ...
- java自动化测试语言高级之HashSet
java自动化测试语言高级之HashSet 文章目录 java自动化测试语言高级之HashSet Java HashSet Java HashSet HashSet 基于 HashMap 来实现的,是 ...
- 打怪升级之小白的大数据之旅(一)＜Java基础语法之Java的身世之谜＞
打怪升级之小白的大数据之旅(一) Java基础语法之Java的身世之谜 打怪升级之小白的大数据之旅(一) 前言 一.学习大数据之前 二.Java基础 what? why? how? 总结 前言 做了几 ...
最新文章
- DPDK — 数据平台优化技术
- springBoot使用PageHelper当超过最大页数后仍然返回数据
- [分享] 数学学术资源站点
- C++与java的不同点
- mysql 三级联动_c#+Mysql 实现三级联动
- 期待鸿蒙是什么意思,如何看待华为将于 6月2 日举办鸿蒙发布会？你对此有哪些期待？...
- iis8.5限速没有效果怎么回事_电梯为何会发生坠梯？没有安全措施吗？能在井道底安装大弹簧吗？...
- python可以处理哪些文件_4招小技巧，带你迅速提升Python文件处理的逼格
- pytorch制作test和train下面还有类别的文件（从一个图片文件中复制）
- java 抽奖算法_Java实现游戏抽奖算法
- 3串口多串口双串口以及2串口UART转WiFi多跳通讯实现二
- 长连接和短连接的定义区别，以及应用场景
- XAMARIN运行IPHONE模拟器
- HTML网页拓展名有哪些,网页文件的扩展名有哪些
- php制作奥运五环颜色代表的洲,php趣味 - php 奥运五环
- 时间线故事脚本_时间轴的创意脚本
- 可移动文物快速三维建模
- 【软考必读】软考高级证书对工作的6大帮助
- 不想升级，iOS系统自动更新可彻底关闭！ 2016-05-23 16:38 更新/自动/on 昨天笔者发布了一篇关于iOS系统总提醒更新，到底要不要升级的文章，不少读者在微信上留言给笔者， iPhon
- Windows 修改键盘映射(附带Linux下Ubuntu的修改方法)
热门文章
- 虚拟路由器备份协议（VRRP）的协议原理与配置
- ATT Device Conformance Requirements - Knowledge Points
- 「天锐绿盾」——数据防泄露（智能透明加密保护）企业加密软件
- 关于设置van-cell单元格的value内容靠左对齐的解决方案
- python空气质量_现在，哪个城市的空气最好闻？空气质量指数分布图——Python实例...
- WEB编程（五）HTML页面内容填充，常用标签介绍
- 【财务_会计1_2】会计的职能与方法
- 第13届景驰-埃森哲杯广东工业大学ACM程序设计大赛 D psd面试 【LCS】
- 简历加分第一步[基于Wordpress搭建个人博客]
- 【八大排序(四)】快排-到底多快才能追上奔驰车里的夏树?