<span>Java基础</span>
一、IDEA的使用
1.1).常用的快捷键
快捷键 | 功能 |
---|---|
Alt+Enter | 导入包,自动修正代码 |
Ctrl+Y | 删除光标所在行 |
Ctrl+D | 复制当前行,插入光标位置的下面 |
Ctrl+Alt+L | 格式化代码 |
Ctrl+/ | 单行注释 |
Ctrl+Shift+/ | 选中代码注释,多行注释,再按取消注释 |
Alt+Ins | 自动生成代码,toString,get,set等方法 |
Alt+Shift+上下箭头 | 移动当前代码行 |
1.2).HelloWorld的JAVA代码书写
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
二、JAVA方法的回顾
2.1).回顾Java方法的定义格式与调用
public static void 方法名称() {
方法体
}
方法名();
注意事项:
1.方法定义的先后顺序无所谓
2.方法定义必须是挨着的,不能在一个方法的内部定义另一个方法
三、JAVA的方法
3.1).方法
方法其实就是若干语句的功能集合
3.2).参数
参数:就是进入方法的数据
3.3).返回值
返回值:就是从方法出来的数据
3.4).定义方法的完整格式
修饰符 返回值类型 方法名称(参数类型 参数名称,....){
方法体
return 返回值;
}
修饰符,现阶段的固定写法,public static
返回值类型,也就是方法最终产生的数据结果是什么类型
方法名称,方法的名字,规则和变量一样,小驼峰
参数类型,进入方法的数据是什么类型
参数名称,进入方法的数据对应的变量名称
ps:参数如果有多个,使用逗号进行分隔
方法体:方法需要做的事情,若干行代码
return,两个作用,第一停止当前方法,第二讲后面的方绘制还给调用处
return后面的返回值,必须和方法名称前面的返回值类型,保持对应
3.5).方法的三种调用格式
a.单独调用
方法名称(参数);
b.打印调用
System.out.println(方法名称(参数));
c.赋值调用
数据类型 变量名称=方法名称(参数)
3.6)方法有参数或无参数
有参数:小括号当中有内容,当一个方法需要一些数据条件,才能完成任务的时候,就是有参数。
无参数:小括号当中留空,一个方法不需要任何数据条件,自己就能独立完成,就是无参数。
3.7)定义方法三要素
返回值类型:boolean
方法名称:isSame
参数列表:int a,int b
3.8)注意事项
a.方法应该定义在类当中,但是不能再方法当中定义方法。不能嵌套。
b.方法定义的前后顺序无所谓。
c.方法定义之后不会执行,如果希望之星,一定要调用:单独调用、打印调用、赋值调用。
d.如果方法有返回值,那么必须写上return 返回值;
e.return后面的返回值数据,必须和方法的返回值类型,对应起来。
f.对于一个void没有返回值的方法,不能写return后面的返回值,只能写return自己。
g.对于方法当中最后一行的return可以省略不写。
h.一个方法当中可以有多个return语句,但是必须保证同事只有一个会被执行到。
3.9)方法的重载(OverLoad)
重载:多个方法的名称一样,但参数列表不一样。
方法的重载与下列因素【有关】
a.参数的股数不同
b.参数类型不同
c.参数的多类型顺序不同
方法的重载与下列因素【无关】
a.与参数的名称无关
b.与参数的返回值无关
例子:
package day04.demo04;
/*
* 比较两个数据是否相等
* 参数类型分别为两个byte类型,两个short类型,两个int类型,两个long类型,并在main方法中进行测试
*
* */
public class Demo02MethodOverloadSame {
public static void main(String[] args) {
byte a = 10;
byte b = 20;
System.out.println(isSame((short) 10,(short) 20));
System.out.println(isSame(11,12));
System.out.println(isSame(10L,10L));
}
public static boolean isSame(byte a, byte b) {
System.out.println("两个byte参数的方法执行");
boolean same;
if (a == b) {
same = true;
} else {
same = false;
}
return same;
}
public static boolean isSame(short a, short b) {
System.out.println("两个short参数的方法执行");
boolean same = a == b ? true : false;
return same;
}
public static boolean isSame(int a, int b) {
System.out.println("两个int参数的方法执行");
return a == b;
}
public static boolean isSame(long a, long b) {
System.out.println("两个long参数的方法执行");
if (a == b) {
return true;
} else {
return false;
}
}
}
println的理解
在调用输出语句的时候,println方法其实就是进行了多种数据类型的重载
四、数组
4.1数组概念:
是一种容器,可以同时存放多个数据值。
4.2数组的特点:
a.数组是一种引用类型
b.数组当中的多个数据,类型必须统一。
c.数组的长度在程序运行期间不可改变
4.3数组的初始化
概念:在内存当中创建一个数组,并且向其中赋予一些默认值。
4.3.1两种常见的初始化方式【标准格式】:
a.动态初始化(指定长度):直接指定数组当中的数据元素个数
//动态初始化数组格式:数据类型[] 数组名称 = new 数据类型[数组长度];
// 创建一个数组,能存放10个double类型的数据
double[] arrayB = new double[10];
// 创建一个数组,能存放5个字符串
String[] arrayC = new String[5];
解析含义:
左侧数据类型:也就是数组当中保存的数据,全都是统一的什么类型。
左侧的中括号:代表是一个数组。
左侧数组名称:给数组取一个名字。
右侧的new:代表创建数组的动作。
右侧的是数据类型:必须和左边的数据类型必须保持一致。
右侧中括号的长度:也就是数组当中,到底可以保存多少数据,是一个int数字。
【注意】使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。规则如下。
a.如果是整数类型:默认为0
b.如果是浮点类型:默认为0.0
c.如果是字符类型:默认为‘\u0000’
d.如果是布尔类型:默认我false
e.如果是引用类型,默认是null
b.静态初始化(指定内容):不直接指定数据个数的多少
//静态初始化的基本格式:数据类型[] 数组名称 = new 数据类型[] {元素1,元素2, .......}
// 直接创建一个数组,里面装的全都是int数字,具体为:5、15、29
int[] arrayA = new int[] {5,15,29,60};
// 创建一个数组,用来装字符串:“Hello”、"World"、"Java"
String[] arrayB = new String[] {"Hello","World","Java"};
注意事项:虽然静态初始化没有直接指定长度,但是根据大括号里面的元素具体内容,也可以自动推算出来长度。
4.3.2静态初始化方式【省略格式】
//格式:数据类型[] 数组名称 = {元素1,元素2,...};
// 省略格式的静态初始化
int[] arrayA = {10,20,30};
注意事项:
a.静态初始化没有直接指定长度,但仍会自动推算长度。
b.静态初始化标准格式可以拆分为两个步骤。
c.动态初始化标准格式也可以拆分为两个步骤。
d.静态初始化一旦使用省略格式,就不能拆分为两个步骤了。
// 静态初始化的标准格式,可以拆分为两个步骤
int[] arrayB;
arrayB = new int[]{11,21,31};
// 动态初始化的标准格式,也可以拆分为两个步骤。
int[] arrayC;
arrayC = new int[5];
使用建议:
如果不确定数组当中的具体内容,用动态初始化。否则,使用静态初始化。
4.3.3访问数组元素进行获取
直接打印数组名称:得到的是数组对应的,内存地址哈希值。
// 静态初始化的省略格式
int[] array = {10, 20, 30};
System.out.println(array);//[I@723279cf
访问数组元素的格式:数组名称[索引值]
索引值:就是一个int数字,代表数组当中元素的编号
【注意】索引值从0开始,一直到“数组的长度-1”为止。
4.4Java的内存划分(5个部分)
a.栈(stack):存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。
局部变量:方法的参数,或者是方法{}内部的变量
作用域:一旦超过作用域,立刻从栈内存当中小时。
b.堆(Heap):凡是new出来的东西,都在堆当中
堆内存里面的东西都有一个地址值:16进制
c.方法区(Method Area):存储.class相关信息,包含方法的信息。
d.本地方法栈(Native Method Stack):与操作系统相关。
e.寄存器(pc Register):与CPU相关。
4.5数组的遍历
获取数组的长度:数组名称.length
4.5.1数组的遍历
//数组的遍历:
for(int i =0; i<array.length; i++){
System.out.println(array[i])
}
五、面向对象
5.1概念:
面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为详细处理每一个细节。
面向过程:当需要实现一个功能的时候,不必关心具体的步骤,而是找一个已经具有该功能的人,来帮我做事。
面向对象的三大特征:封装、继承、多态。
5.2类和对象
5.2.1如何创建类:包含两个
a.属性(成员属性)
b.行为(成员方法)
public void 方法名称(){} //不需要写static
5.2.2如何使用类
a.导包:也就是支出需要使用的类,在什么位置
import 包名称.类名称;
【注意】对于和当前类属于同一个包的情况,可以省略导包语句不写。
b.创建,格式
类名称 对象名 =new 类名称();
Student stu = new Student();
c.使用,分为两种情况:
使用成员变量:对象名.成员变量名
stu.name 或者 stu.age
使用成员方法:对象名.成员方法名(参数)
stu.eat() 或者 stu.say()
当使用一个对象类型作为方法的【返回值】时:返回值其实就是对象的【地址值】
5.2.3局部变量和成员变量
a.定义的位置不一样【重点】
局部变量:在方法的内部
成员变量:在方法的外部,直接写在类中
b.作用的范围不一样【重点】
局部变量:只有在方法当中才可以使用,出了方法就不能再用
成员变量:整个类都可以使用
c.默认值不一样【重点】
局部变量:没有默认值,如果想要使用,必须手动赋值。
成员变量:如果没有赋值,会有默认值,规则和数组一样。
5.2.4Getter和Setter的引入
问题描述:定义person类的年龄时,无法阻止不合理的数值被设置进来。
解决方案:用private关键字将需要保护的成员变量进行修饰。
5.2.5一旦使用了private进行修饰,那么在本类中可以随意访问。但是,超出本类范围就不能【直接访问】
解决:间接访问private成员变量,就是定义一对Getter/Setter方法
命名规则:必须是setxxx或者是getxxxx来命名。
对于Getter来说,不能有参数,返回值类型和成员变量对应;
对于Setter来说,不能有返回值,参数类型和成员变量对应。
对于基本类型当中的boolean值,Getter方法一定要写成isXxx的形式,而Setter规则不变。【重点】
5.2.6 类的this的引入
当方法的局部变量和类的成员变量重名的时候,根据“就近原则”,优先使用局部变量。如果需要访问本类房中的成员变量,需要使用格式 this.成员变量名
5.2.7类构造方法
概念:构造方法是专门用来创建对象的方法,当我们通过关键字new来创建对象时,其实就是在调用构造方法。
格式:
public 类名称(参数类型 参数名称){
方法体
}
【注意事项】
1.构造方法的名称必须和所在的类名称完全一样,就连大小写也要一样。
2.构造方法不要写返回值类型,连void都不写。
3.构造方法不能return一个具体的返回值。
4.如果没有编写任何构造方法,那么编译器将会默认赠送一个构造方法,没有参数、方法体什么事情都不做。
public Student(){}
5.一旦编写了至少一个构造方法,那么编译器将不再赠送。
6.构造方法也是可以进行重载的。
重载:方法名称相同,参数列表不同。
5.2.8标准类的组成部分(四个组成部分)
1.所有的成员变量都要使用private关键词修饰
2.为每一个成员变量编写一对Getter/Setter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法
代码:
package day04.ClassAndObject;
public class perSon {
private String name;
private int age;
//无参数构造函数
public perSon() {
}
//全参数构造函数
public perSon(String name, int age) {
this.name = name;
this.age = age;
}
//Getter
public String getName() {
return name;
}
//Setter
public void setName(String name) {
this.name = name;
}
//Getter
public int getAge() {
return age;
}
//Setter
public void setAge(int age) {
this.age = age;
}
}
六、JAVA_API
6.1引用类型的一般使用步骤
1.导包
import 包路径.类名称;
如果需要使用目标类,和当前类位于同一个包下,则可以省略导包语句。
只有java.lang包下的内容不需要导包,其他的包都需要import语句。
2.创建
类名称 对象名 = new 类名称();
3.使用
对象名.成员方法();
6.2 Scanner类 (键盘输入)
功能:可以实现键盘输入数据,到程序当中
package Scanner;
import java.util.Scanner;
/*
* 获取键盘输入的int类型 int num = sc.nextInt();
* 获取键盘输入的String类型 String str = sc.next();
* */
public class Demo01Scanner {
public static void main(String[] args) {
// System.in是获取键盘输入
Scanner sc = new Scanner(System.in);
// 获取键盘输入的int 类型
int num = sc.nextInt();
System.out.println("键盘输入的int类型是:"+ num);
// 获取键盘输入的String类型
String str = sc.next();
System.out.println("获取的键盘输入的String类型是:"+ str);
}
}
6.3 Ramdom类 (随机数)
功能:用来生成随机数字。
使用步骤:
1.导包
import java.until.Random
2.创建
Random r = new Random();
3.使用
获取一个随机的int数字(范围是int所有范围,有正负两种)。 int num = r.nextInt();
package Random;
import java.util.Random;
public class Demo01Random {
public static void main(String[] args) {
// 创建对象
Random r = new Random();
for (int i = 0; i < 100; i++) {
int num = r.nextInt(10) + 1 ;
System.out.println("随机数是:"+ num);
}
}
}
6.4猜数字小游戏 (利用Random和Scanner)
无限次猜测 while(true)
package Random;
import java.util.Random;
import java.util.Scanner;
/*
* 猜数字小游戏实例 无限次猜测 while(true)
* 运用到Random随机数 和Scanner获取键盘输入
* */
public class Demo02RandomAndScanner {
public static void main(String[] args) {
// 创建Random对象
Random r = new Random();
// 获取随机数
int randomNum = r.nextInt(100) + 1;
// 创建Scanner对象
Scanner sc = new Scanner(System.in);
// 利用while(true) 循环进行猜测
while (true){
System.out.println("请输入你猜测的数字:");
int guessNum = sc.nextInt();
if (guessNum > randomNum){
System.out.println("太大了,请重试!");
}else if(guessNum < randomNum){
System.out.println("太小了,请重试!");
}else{
System.out.println("猜对了,游戏结束!");
break;
}
}
}
}
有限次猜测 for
package Random;
import java.util.Random;
import java.util.Scanner;
/*
* 猜数字小游戏实例
* 运用到Random随机数 和Scanner获取键盘输入
* */
public class Demo02RandomAndScanner {
public static void main(String[] args) {
// 创建Random对象
Random r = new Random();
// 获取随机数
int randomNum = r.nextInt(100) + 1;
// 创建Scanner对象
Scanner sc = new Scanner(System.in);
// 利用for循环,固定猜测的次数,到了固定次数没有猜对,挑战失败
for (int i = 0; i <= 5; i++) {
if(i < 5){
System.out.println("请输入你猜测的数字:");
int guessNum = sc.nextInt();
if (guessNum > randomNum){
System.out.println("太大了,请重试!");
}else if(guessNum < randomNum){
System.out.println("太小了,请重试!");
}else{
System.out.println("猜对了,游戏结束!");
}
}else{
System.out.println("挑战失败!");
}
}
}
}
6.5 ArrayList类
引入:数组的长度在程序执行的时候,不可以发生改变。
但是ArratList集合的长度是可以随意变化的。
对于ArrayList来说,有一个尖括号 <e> 代表泛型。 </e>
泛型:也就是装在集合当中的所有元素,全都是统一类型的数据。
注意:泛型只能是引用类型,不是基本类型。
1.注意事项:对于ArrayList集合来说,直接打印的不是地址值,而是内容。如果内容是空,得到的是空的中括号。[ ]
package ArrayList;
import java.util.ArrayList;
public class Demo01ArrayList {
public static void main(String[] args) {
// 从JDK1.7+开始,右侧的尖括号内部可以不写内容,但是<>本身还是要写的。
ArrayList<String> list = new ArrayList<>();
// 往集合中添加数据需要用到add方法
list.add("赵丽颖");
System.out.println(list);
list.add("古力娜扎");
list.add("欧阳娜娜");
list.add("马尔扎哈");
System.out.println(list);
}
}
2. ArratList 当中的常用方法
public boolean add(E e):向集合中添加元素,参数的类型和泛型一致。
public E get(int index):从集合中获取元素,参数是索引编号,返回值是对应位置的元素
public E remove(int index):从集合中删除元素,参数是索引编号,返回值是被删除的元素
public int size():获取集合的长度,返回值是集合中包含的元素个数。
package ArrayList;
import java.util.ArrayList;
public class Demo02ArrayListMethod {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
// add方法添加元素
list.add("赵丽颖");
list.add("古力娜扎");
list.add("欧阳娜娜");
boolean isAdd = list.add("李小璐");
System.out.println("是否添加成功:"+isAdd);
System.out.println(list);
// get方法 获取元素
String name = list.get(2);
System.out.println("获取的元素是:" + name);
// remove方法 删除元素
String rename = list.remove(3);
System.out.println("删除的人是:" + rename);
System.out.println(list);
// size方法 获取ArrayList的大小
int listSize = list.size();
System.out.println("大小是:" + listSize);
}
}
3.遍历ArrayList
package ArrayList;
import java.util.ArrayList;
public class Demo03ArrayListEach {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("古力娜扎");
list.add("欧阳娜娜");
list.add("迪丽热巴");
list.add("马尔扎哈");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
3.向集合ArrayList当中存储基本数据类型,必须使用基本类型对应的“包装类”
基本类型 | 包装类(引用类型,包装类都位于java.lang包下) | |
---|---|---|
byte | Byte | |
short | Short | |
int | Integer | 【特殊】 |
long | Long | |
float | Float | |
double | Double | |
char | Character | 【特殊】 |
boolean | Boolean |
package ArrayList;
import java.util.ArrayList;
public class Demo04ArrayListBasic {
public static void main(String[] args) {
// 将Integer当做Int 类型使用
ArrayList<Integer> list = new ArrayList<>();
list.add(100);
list.add(200);
System.out.println(list);
int num = list.get(1);
System.out.println("索引值为第1号元素是:" + num);
}
}
4.例子
1.
package ArrayList;
import java.util.ArrayList;
import java.util.Random;
/*
* 题目:生成6个1~33之间的整数,添加到集合,并遍历集合
*
* 思路:
* 1.需要储存3个数字,创建一个集合 :<Integer>
* 2.产生随机数,用到Random
* 3.用循环6次,来产生6个随机数字,for循环
* 4.循环内调用r.nextInt(int n),参数是33,0~32 整体+1 就是 1~33
* 5.遍历集合 for,size,get
* */
public class Demo05ArrayListRandom {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 6; i++) {
int num = r.nextInt(33) + 1;
list.add(num);
}
for (int j = 0; j < list.size(); j++) {
System.out.println(list.get(j));
}
}
}
2.
package ArrayList;
import java.util.ArrayList;
/*
* 题目:自定义4个学生对象,添加到集合,并遍历
*
* 思路:
* 1.自定义一个Student类,四个部分。
* 2.创建一个集合,用来存储学生对象。泛型:<Student>
* 3.根据类,创建4个学生对象
* 4.将4个学生对象添加到集合中。 add
* 5.遍历集合: for 、size、get
* */
public class Demo06ArrayListStudent {
public static void main(String[] args) {
// 创建一个集合
ArrayList<Student> list = new ArrayList<>();
// 创建4个学生对象
Student one = new Student("杨过", 21);
Student two = new Student("小龙女", 22);
Student three = new Student("黄药师", 23);
Student four = new Student("老顽童", 24);
// 添加到集合
list.add(one);
list.add(two);
list.add(three);
list.add(four);
// 遍历集合
for (int i = 0; i < list.size(); i++) {
Student stu = list.get(i);
System.out.println("姓名:" + stu.getName() + ",年龄:"+stu.getAge());
}
}
}
3.
package ArrayList;
/*
* 题目:定义指定格式打印集合的方法(ArrayList类型作为参数),使用{}括起来,使用@符号分隔。
* 格式参照 {元素@元素@元素}
* */
import javax.lang.model.element.NestingKind;
import java.util.ArrayList;
public class Demo07ArrayListPrint {
public static void main(String[] args) {
// 创建集合
ArrayList<String> list = new ArrayList<>();
// 添加元素
list.add("小鱼儿");
list.add("花无缺");
list.add("张无忌");
list.add("方世玉");
System.out.println(list); //[小鱼儿, 花无缺, 张无忌, 方世玉]
// 调用自定义方法
printArrayList(list);
}
/*
* 定义方法的三要素
* 返回值: 只是进行打印,没有运算,没有结果,所以用void
* 方法名称:printArrayList
* 参数列表:ArrayList
* */
public static void printArrayList(ArrayList<String> list){
System.out.print("{");
for (int i = 0; i < list.size(); i++) {
String name = list.get(i);
if(i == list.size() -1){
System.out.print(name + "}");
}else{
System.out.print(name + "@");
}
}
}
}
3.
package ArrayList;
/*
* 题目:
* 用一个大集合存入20个随机数字,然后筛选其中的元素,放到小集合中,要求使用自定义的方法实现筛选
*
* 分析:
* 1.需要创建一个大集合,用来存放int数字 <Integer>
* 2.随机数字用Random nextInt
* 3.循环20次,把随机数字放入大集合:for循环、add方法
* 4.定义一个方法,用来进行筛选
* 定义方法的三要素:
* 返回值: ArrayList小集合 (元素个数不确定)
* 方法名称:getSmallList
* 参数列表:ArrayList大集合 (装着20个随机数字)
* 5.判断是偶数,num%2==0 用if语句
* 6.如果是偶数,就放到小集合当中,否则不放
* */
import java.util.ArrayList;
import java.util.Random;
public class Demo08ArrayListReturn {
public static void main(String[] args) {
// 创建集合对象
ArrayList<Integer> bigList = new ArrayList<>();
// 创建随机数字对象
Random r = new Random();
for (int i = 0; i < 20; i++) {
int num = r.nextInt(100) + 1;
bigList.add(num);
}
ArrayList<Integer> smallList = getSmallList(bigList);
System.out.println("偶数个数是:" + smallList.size());
for (int i = 0; i < smallList.size(); i++) {
System.out.println(smallList.get(i));
}
}
public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList){
// 创建一个小集合
ArrayList<Integer> smallList = new ArrayList<>();
for (int i = 0; i < bigList.size(); i++) {
Integer num = bigList.get(i);
if(num%2==0){
smallList.add(num);
}
}
return smallList;
}
}
6.6字符串
java.lang.String类代表字符串
API当中表示:Java程序中的所有字符串字面值(如 “abc”)都作为此类的实现。
其实就是说:程序当只能够所有的双引号字符串,都是String类型。(就是算没有new,也照样是。)
1.字符串的特点:
1.字符串的内容永不可变。【重点】
2.正是因为字符串永不可变,所以字符串是可以共享使用的。
3.字符串效果相当于是char[]字符数组,但是底层原理是byte[]字节数组。
2.创建字符串的常见3+1种方式:
三种构造方法:
public String(): 创建一个空白字符串,不含有任何内容。
public String(char[] array): 根据字符数组的内容,来创建对应的字符串。
public String(byte[] array): 根据字节数组的内容,来创建对应的字符串。
一种直接创建:
String str = "hello";
package StringAPI;
public class Demo01String {
public static void main(String[] args) {
// 使用空参构造
String str1 = new String();
System.out.println("第一个字符串:" + str1);
// 根据字符数组创建字符串
char[] charArray = {'A','B','C'};
String str2 = new String(charArray);
System.out.println("第二个字符串:" + str2);
// 根据字节数组创建字符串
byte[] byteArray = {97,98,99};
String str3 = new String(byteArray);
System.out.println("第三个字符串:"+ str3);
// 直接创建
String str4 = "hello";
System.out.println("第四个字符串:" + str4);
}
}
3.字符串常量池
概念:程序当中直接写上的双引号字符串,就在字符串常量池中。
对于基本类型来说,==是进行数值的比较。
对于引用类型来说,==是进行【地址值】的比较。
package StringAPI;
public class Demo02StringPool {
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
char[] charArray = {'a','b','c'};
String str3 = new String(charArray);
System.out.println(str1 == str2); //true
System.out.println(str1 == str3); //false
System.out.println(str2 == str3); //false
}
}
4.字符串内容的比较 (equals)
==是进行对象的地址值比较,如果确实需要字符串的内容比较,可以使用两种方法。
a. public boolean equals(Object obj): 参数可以是任何对象,只有参数是一个字符串并且有内容相同时才会返回true,否则返回false
【注意】:1.任何对象都能用Object进行接收。
2.equals方法具有对称性。也就是 a.equals(b)和b.equals(a)效果一样。
3.如果比较双方一个常量一个变量,推荐把常量字符串写在前面。 推荐:"abc".equals(str) 不推荐:str.equals("abc")
b. public boolean equalsIgnoreCase(String str): 忽略大小写,进行内容比较。
package StringAPI;
public class Demo03StringEquals {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "hello";
char[] strArray = {'H','e','l','l','o'};
String str3 = new String(strArray);
System.out.println(str1.equals(str3)); //true
System.out.println(str1.equalsIgnoreCase(str2)); //true
}
}
5.与获取相关的方法
public int length(): 获取字符串当中含有的字符个数,拿到字符串长度。
public String concat(String str): 将当前字符串和参数字符串拼接成为返回值新的字符串
public char charAt(int index): 获取指定索引位置的单个字符。(索引从0开始)
public int indexOf(String str): 查找参数字符串在本字符串当中首次出现的索引位置,如果没有,返回-1值。
6.字符串截取(substring)
public String substring(int index): 截取从参数位置一直到字符串末尾,返回新字符串。
public String substring(int begin,int end): 截取从begin开始,一直到end结束,中间的字符串。 【备注】:[begin,end)包含左边,不包含右边。
7.字符串与转换相关的方法
public char[] toCharArray(): 将当前字符串拆分为字符数组作为返回值。
public byte[] getBytes(): 获得当前字符串底层的字节数组。
public String replace(CharSequence oldString,CharSequence newString): 将所有出现的老字符串替换成为新的字符串,返回替换之后的结果,新字符串。
package StringAPI;
public class Demo04StringConvert {
public static void main(String[] args) {
// toCharArray() 拆分字符串,拆分成为字符数组
char[] chars = "hello".toCharArray();
System.out.println(chars[0]); //h
System.out.println(chars.length); //5
// replace(oldString,newString) 替换字符串
String str1 = "***勒,***吧!***吧!***吧!";
String str2 = str1.replace("***", "*");
System.out.println(str2);
}
}
8.分割字符串(split)
public String[] split(String regex): 按照参数的规则,将字符串切成若干部分。
package StringAPI;
public class Demo05StringSplit {
public static void main(String[] args) {
String str1 = "aaa,ccc,bbb";
String[] array1 = str1.split(",");
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
}
}
9.字符串实例
1.字符串自定义拼接
package StringAPI;
/*
* 题目:
* 定义一个方法,把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下:[word1#word2#word3]
*
* 分析:
* 1.首先准备一个int[]数组,内容是:1、2、3
* 2.定义一个方法,用来将数组变成字符串
* 定义方法的三要素:
* 返回值:String
* 方法名称:fromArrayToString
* 参数列表:int[]
* 3.格式:[word1#word2#word3]
* 用到:for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用#、区分是否为最后一个
* 4.调用方法,得到返回值,并打印结果字符串
* */
public class Demo06StringPractise {
public static void main(String[] args) {
int[] array1 = {1,2,3};
String str2 = fromArrayToString(array1);
System.out.println(str2); //[word1#word2#word3]
}
public static String fromArrayToString(int[] array1){
String str = "[";
for (int i = 0; i < array1.length; i++) {
if(i == array1.length -1){
str += "word" + array1[i] + "]";
}else{
str += "word" + array1[i] + "#";
}
}
return str;
}
}
2.统计键盘输入的各种字符的次数
package StringAPI;
/*
* 题目:
* 键盘输入一个字符串,并且统计其中各种字符出现的次数。
* 种类有:大写字母、小写字母、数字、其他字符
*
* 思路:
* 1.用到键盘输入,那么就用Scanner
* 2.键盘输入的是字符串,那么 String str = sc.next()
* 3.定义4个变量,分别代表四中字符出现的次数
* 4.需要对字符串每个字检查,String --> char[],用法的方法 toCharArray()
* 5.遍历char[]字符数组,对当前字符的种类进行判断,并且用四个变量进行++动作。
* 6.打印输出4个变量,分别代表四种字符出现的次数。
* */
import java.util.Scanner;
public class Demo07StringCount {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String str = sc.next();
int countUpper = 0;
int countLower = 0;
int countNumber = 0;
int countOther = 0;
char[] array = str.toCharArray();
for (int i = 0; i < array.length; i++) {
char ch = array[i];
if('A' <= ch && ch <= 'Z'){
countUpper++;
}else if('a' <= ch && ch <= 'z'){
countLower++;
}else if('0' >= ch && ch <= '9'){
countNumber++;
}else{
countOther++;
}
}
System.out.println("大写字母:"+countUpper+"个");
System.out.println("小写字母:"+countLower+"个");
System.out.println("数字字符:"+countNumber+"个");
System.out.println("其他字符:"+countOther+"个");
}
}
七、Static关键字
7.1 static特点
一旦用了static关键字,那么这样的内容不再属于自己,而是属于类的,所以凡是本类的对象,都共享同一份。
7.2 静态成员变量和静态成员方法
如果没有static关键字,那么首先创建对象,然后通过对象才能使用它。
如果已经有static关键字,那么不需要创建对象,直接就能通过类名称来使用它。
无论是成员变量,还是成员方法。如果有了static.都推荐使用类名称调用。
静态变量:类名称.静态变量
静态方法: 类名称.静态方法()
【注意事项】:
1.静态不能直接访问非静态
原因:因为在内存当中是【先】有静态内容,【后】有非静态内容。“先人不知道后人,但是后人知道先人”
2.静态方法中不能用this
原因:this代表当前对象,通过谁调用的方法,谁就是当前对象。
3.根据类名称访问静态成员变量的时候
全程和对象没有关系,只跟类有关系。
学生类
package StaticDemo;
public class Student {
private int id; //学号
private String name; //姓名
private int age; //年龄
static String room; //教室
private static int idCounter = 0; //学号计数器
public Student() {
idCounter++;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++idCounter;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package StaticDemo;
public class Demo01Static {
public static void main(String[] args) {
Student one = new Student("曾祥连",20);
one.room = "重庆航天职业技术学院A-2-508";
System.out.println("姓名:"+ one.getName() + ",年龄:" + one.getAge() + ",教室:" + Student.room + ",学号:" + one.getId());
Student two = new Student("张三丰",22);
System.out.println("姓名:"+ two.getName() + ",年龄:" + two.getAge() + ",教室:" + Student.room + ",学号:" + two.getId());
}
}
7.3 静态代码块
格式:
public class 类名称{
static{
//静态代码的内容
}
}
特点:当第一次用到本类时,静态代码块执行唯一的一次。
静态内容总是优先于非静态,所以静态代码块比构造方法先执行。
静态代码块的典型用途:
用来一次性的对静态成员变量进行赋值。
八、Arrays工具类
是一个与数组相关的工具类,里面提供了大量静态方法,用来实现数组常见的操作。
public static String toString(数组),将参数数组变成字符串(按照默认格式:[元素1,元素2,元素3……])
public static void sort(数组),按照默认升序(从小到大)对数组的元素进行排序。
【备注】:
1.如果是数值,sort默认按照升序从小到大
2.如果是字符串,sort默认按照字母升序
3.如果是自定义的类型,那么这个自定义的类需要Comparable或者Comparator接口的支持。
package ArraysDemo;
/*
* 题目:
* 使用相关的Arrays相关的API,将一个随机字符串中的所有字符升序排列,并倒序打印。
* */
import java.util.Arrays;
public class Demo01Arrays {
public static void main(String[] args) {
String str = "afkhakf7failfja8cznjv";
// 进行升序排列 sort
// 必须是一个数组,才能用Arrays.sort方法
// String --> 数组,用toCharArray
char[] chars = str.toCharArray();
Arrays.sort(chars); //对字符数组进行升序排列
// 倒序遍历
for (int i = chars.length - 1; i >= 0; i--) {
System.out.println(chars[i]);
}
}
}
九、继承
在父子类的继承关系当中,创建子类对象,访问成员方法的规则:
创建的对象是谁,就优先用谁,如果没有则向上找。
【注意事项】:无论是成员方法还是成员变量,如果没有都是向上找父类,绝对不会向下找子类。
9.1 变量
局部变量 | 直接写成员变量名 |
---|---|
本类的成员变量 | this.成员变量名 |
父类的成员变量 | super.成员变量名 |
9.2 重写与重载
重写(Override):
概念:在继承关系当中,方法的名称一样,参数列表【也一样】。覆盖、覆写。
【方法覆盖重写的注意事项】
1.必须保证父子类之间方法的名称相同,参数列表相同。
@Override : 写在方法前面,用来检测是不是有效的正确覆盖重写。
这个注解就算不写,只要满足要求,也是正确的方法覆盖重写。
2.子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展:java.lang.Object类是所有类的公共最高父类(祖宗类),java.lang.Stringt就是Object的子类。
3.子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展:public > protected > (default) > private
备注:(default)不是关键字,而是什么都不写,留空。
重载(Overload):
概念:在继承关系中,方法的名称一样,参数列表【不一样】。
方法的覆盖重写特点:创建的是子类对象,则优先用子类方法。
9.3父子类构造方法的访问特点
1.子类构造方法当中有一个默认隐含的“super()”调用,所以一定是先调用的父类的构造方法,后执行的子类构造。
2.子类构造可以通过super关键字来调用父类重载构造。
3.super的父类构造调用,必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
【总结】:子类必须调用父类构造方法,不写则赠送super();写了则用写的指定的super调用,super只能有一个。
9.4 super关键字用来访问父类内容,而this关键字用来访问本类内容
1.在本类的成员方法中,访问本类的成员变量。
2.在本类的成员方法中,访问本类的另一个成员方法。
3.在本类的构造方法中,访问本类的另一个构造方法。
在第三种用法中要注意: A:this(...)调用也必须是构造方法的第一个语句,唯一一个。
B: super 和this两种构造调用,不能同时使用。
9.5 Java语言是【单继承】
1.一个类的直接父类只能有唯一一个。
2.Java语言可以【多级继承】
3.一个子类的直接父类是唯一一个,但是一个父类可以拥有很多歌子类。【二胎】
十、抽象
10.1抽象方法和抽象类
抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结束。
抽象类:抽象方法所在的类,必须是抽象类才行。在class之前写上abstract即可。
10.2如何使用抽象类和抽象方法
1.不能直接创建new抽象类对象
2.必须用一个子类来继承抽象父类。
3.子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后不上方法体大括号。
4.创建子类对象进行使用。
10.3实现方法
概念:子类对父类抽象方法的完成实现,将这种方法重写的操作就叫实现方法。
10.4注意事项
1.抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。
2.抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
理解:子类的构造方法中,有默认的super(),需要访问父类的构造方法。
3.抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。
4.抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。
理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。
十一、接口
接口的概念:
a.接口就是多个类的公共规范。
b.接口是一种引用数据类型,最重要的内容技术其中的:抽象方法。
11.1如何定义一个接口的格式
public interface 接口名称{
//接口内容
}
备注:换成了关键字interface之后,编译生成的字节码文件仍然是: .java --> .class 。
Java7:接口内容包括的内容有: 1.常量 2.抽象方法
Java8:额外包括: 3.默认方法 4.静态方法
Java9 : 额外包括:5.私有方法
11.2 在任何版本的java中,接口都能定义抽象方法
格式:
public abstract 返回值类型 方法名称(参数列表);
注意事项:
> 1.接口当中的抽象方法,修饰符必须是两个固定的关键字:public abstract
>
> 2.这两个关键字修饰符,可以选择性省略。(刚学,不推荐省略)
>
> 3.方法的三要素,可以随意定义。
package MyInterface;
public interface MyInterfaceAbstract {
// 这是一个抽象方法
public abstract void methodAbs1();
// 这也是抽象方法
public void methodAbs2();
// 这也是抽象方法
abstract void methodAbs3();
// 这是抽象方法
void methodAbs4();
}
11.3接口的使用步骤
1.接口不能直接使用,必须有一个“实现类”来“实现”该接口。
格式:
public class 实现类名称 implements 接口名称{
// .....
}
2.接口的实现类必须覆盖重写(实现)接口中所有的抽象方法。
实现:去掉abstract关键字,加上方法体大括号。
3.创建实现类的对象,进行使用。
【注意事项】:如果实现类并没有覆盖冲邪恶接口中所有的抽象方法,那么这个实现类自己就必须是抽象了。
package MyInterface;
/*
这是接口
*/
public interface MyInterfaceAbstract {
// 这是一个抽象方法
public abstract void methodAbs1();
// 这也是抽象方法
public void methodAbs2();
// 这也是抽象方法
abstract void methodAbs3();
// 这是抽象方法
void methodAbs4();
}
package MyInterface;
/*
这是实现类
*/
public class MyInterfaceImpl implements MyInterfaceAbstract {
@Override
public void methodAbs1() {
System.out.println("这是方法一");
}
@Override
public void methodAbs2() {
System.out.println("这是方法二");
}
@Override
public void methodAbs3() {
System.out.println("这是方法三");
}
@Override
public void methodAbs4() {
System.out.println("这是方法四");
}
}
package MyInterface;
public class Demo01Main {
public static void main(String[] args) {
// 实现类的对象使用
MyInterfaceImpl impl = new MyInterfaceImpl();
impl.methodAbs1(); //这是方法一
impl.methodAbs2(); //这是方法二
}
}
11.4接口的默认方法
默认方法的定义:
public default 返回值类型 方法名称(参数列表){
}
1.接口的默认方法,可以通过接口实现类对象,直接调用。
2.接口的默认方法,也可以被接口实现类进行覆盖重写。
/*
接口
*/
package Demo01Interface;
public interface MyInterfaceDefault {
public abstract void methodA();
public abstract void methodB();
/*
默认方法的定义:
public default 返回值类型 方法名称(参数列表){
}
*/
public default void methodDefault(){
System.out.println("这是默认方法!");
}
}
/*
第一个实现类
*/
package Demo01Interface;
public class MyInterfaceDefaultImpl01 implements MyInterfaceDefault
{
@Override
public void methodA() {
System.out.println("方法一");
}
@Override
public void methodB() {
System.out.println("方法二");
}
}
/*
第二个实现类
*/
package Demo01Interface;
public class MyInterfaceDefaultImpl01 implements MyInterfaceDefault
{
@Override
public void methodA() {
System.out.println("方法一");
}
@Override
public void methodB() {
System.out.println("方法二");
}
}
/*
主方法
*/
package Demo01Interface;
public class Demo01Main {
public static void main(String[] args) {
// 第一个实现类
MyInterfaceDefaultImpl01 impl01 = new MyInterfaceDefaultImpl01();
impl01.methodA(); //方法一
impl01.methodDefault(); //这是默认方法!
System.out.println("===============");
// 第二个实现类
MyInterfaceDefault02 impl02 = new MyInterfaceDefault02();
impl02.methodA(); //方法一
impl02.methodDefault(); //覆盖重写了接口的默认方法
}
}
11.5接口小总结
【在Java 9+版本中,接口的内容可以有:】
1.成员变量其实是常量,格式:
[public] [static] [final] 数据类型 常量名称 = 数据值;
注意: a.常量必须进行复制,而且一旦复制不能改变。
b.常量名称完全大写,用下划线进行分隔。
2.接口中最重要的就是抽象方法,格式
[public] [abstract] 返回值类型 方法名称(参数列表);
注意:实现类必须覆盖重写接口所有的抽象方法,除非实现类是抽象类。
3.从Java 8开始,接口里允许定义默认方法,格式:
[public] default 返回值类型 方法名称(参数列表){
//方法体
}
注意:默认方法也可以被覆盖重写。
4.从Java 8开始,接口里允许定义鼎泰方法。格式:
[public] static 返回值类型 方法名称(参数列表){
//方法体
}
注意:应该通过接口名称进行调用,不能通过实现类对象调用接口静态方法。
5.从Java 9开始,接口里允许定义私有方法。格式:
//普通私有方法
private 返回值类型 方法名称(参数列表){
//方法体
}
//静态私有方法
private static 返回值类型 方法名称(参数列表){
//方法体
}
注意:private 的方法只有接口自己才能调用,不能被实现类或者别人使用。
11.6 实现多个接口
使用接口的时候,需要注意:
1.接口是没有静态代码块或者构造方法的。
2.一个类的直接父类是唯一的,但是一个类可以同时实现多个接口。
格式:
public class 类名称 implements 接口一,接口二{
//覆盖重写所有抽象方法
}
3.如果实现类所实现的多个接口当中,存在重复的抽象方法,那么只需要覆盖重写一次即可。
4.如果实现类没有覆盖重写所有接口当中的所有抽象方法,那么实现类必须是一个抽象类。
5.如果实现类在实现多个接口当中,存在重复的默认方法,那么实现类一定要对冲突的默认方法进行覆盖重写。
6.一个类如果直接父类当中的方法,和接口当中的默认方法产生了冲突,优先用父类当中的方法。
11.7接口之间的继承
1.类与类之间是单继承的。直接父类只有一个。
2.类与接口之间是多实现的。一个类可以实现多个接口。
3.接口与接口之间是多继承的。
【注意事项】:
1.多个父接口当中的抽象方法如果重复,没关系。
2.多个父接口当中的默认方法如果重复,那么子接口必须进行默认方法的覆盖重写,【而且带着default关键字】
十二、多态
12.1概念:
多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口,使用不同的实例而执行不同操作,如图:
代码当中体现多态性,其实就是,父类引用指向子类。
格式:
父类名称 对象名 = new 子类名称();
//或者
接口名称 对象名 = new 实现类名称();
12.2访问成员变量的两种方式和访问成员方法的规则
【成员变量】:
1.【直接】通过对象名称访问成员变量:看等号左边是谁,优先用谁,没有则向上找。
2.【间接】通过成员方法访问成员变量:看该方法属于谁,优先用谁,没有则向上查找。
【成员方法】:
在多态的代码当中,成员方法的访问规则是:
看new的是谁,就优先用谁,没有则向上找。
【总结】:
成员方法:编译看左边,运行还看左边。
成员方法:编译看左边,运行看右边。
12.3多态的写法
package Demo01;
public class Demo01Main {
public static void main(String[] args) {
// 如果不用多态,只用子类的写法
Teacher one = new Teacher();
one.work();//讲课
Assistant two = new Assistant();
two.work();
System.out.println("==========================");
// 如果使用多态,那么写法是:
Person three = new Teacher();
three.work(); //讲课
Person four = new Assistant();
four.work(); //辅导
}
}
12.4对象的向上转型
对象的向上转型,其实就是多态写法:
//格式
父类名称 对象名 = new 子类名称();
含义:右侧创建一个子类对象,把它当做父类来看待使用。
注意事项:向上转型一定是安全的。从小范围转向大范围,从小范围的猫,向上转换成为更大范围的动物。
Animal animal = new Cat(); //创建了一直猫,当做动物看待
12.5对象的向下转型
对象的乡下转型,其实是一个【还原】的动作。
//格式
子类名称 对象名 = (子类名称)父类对象
含义:将父类对象,【还原】成为本来的子类对象。
Animal animal = new Cat();//本来是猫,向上转型成为动物
Cat cat = (Cat)animal; //本来是猫,已经被当成动物,还原回来成为本来的猫
注意事项:
a.必须保证对象本来创建的时候,就是猫,才能向下转型成为猫
b.如果对象创建的时候本来不是猫,现在非要向下转型成为猫,就会报错。
十三、final
final关键字代表最终,不可改变的。
常见的四种用法:
1.可以用来修饰一个类。
当final关键字修饰一个类的时候,格式
public final class 类名称{
//...
}
2.可以用来修饰一个方法
当final关键字修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写
格式:
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
3.还可以用来修饰一个局部变量
一旦使用final用来修饰局部变量,那么这个变量就不嗯能够进行更改。
“一次赋值,终身不变”
4.还可以用来修饰一个成员变量
对于成员变量来说,如果使用了final关键字修饰,那么这个变量也照样是不可变。
1.由于成员变量就有默认值,所以用了final之后必须手动赋值,不会再给默认值了。
2.对于final的成员变量,要么使用直接赋值,要么通过构造方法赋值。二者选其一。
3.必须保证当中所有重载的构造方法,都最终会对final的成员变量进行赋值。
十四、Java中的四种修饰符
public | protected | (default) | private | |
---|---|---|---|---|
同一个类(我自己) | yes | yes | yes | yes |
同一个包(我邻居) | yes | yes | yes | no |
不同包子类(我儿子) | yes | yes | no | no |
不同包非子类(陌生人) | yes | no | no | no |
【注意事项】:(default)并不是关键字"default",而是根本不写。
十五、内部类
如果一个十五的内部包含另一个十五,那么这就是一个类内部包含另一个类。
分类:
15.1.成员内部类
成员内部类的定义格式:
修饰符 class 外部类名称{
修饰符 class 内部类名称{
//....
}
//.....
}
注意:内用外,随意访问;外用内,需要内部类对象。
15.1.1如何使用成员内部类?有两种方式:
1.间接方式: 在外部类的方法当中,使用内部类,然后main只是调用外部类的方法。
2.直接方式:公式:
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称()】
15.1.2如果出现【重名现象】,那么格式是:外部类名称.this.外部类成员变量名
12.2.局部内部类
如果一个类是定义在一个方法内部的,那么这就是一个局部内部类。
“局部”:只有当前所属的方法才能使用它,除了这个方法外面就不能用了。
定义格式:
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称(参数列表){
class 局部内部类名称{
//....
}
}
}
12.2.1内部类中的权限修饰符
public > protected >(default) >private
定义一个类的时候,权限修饰符规则
1.外部类:public /(default)
2.成员内部类:public / protected / (default) / private
3.局部内部类:什么都不写
12.3局部内部类
如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】。
备注:从Java 8+开始,只要局部变量事实不变,那么final关键字可以省略。
原因:
1.new出来的对象在堆内存当中。
2.局部变量是跟着方法走的,在栈内存当中。
3.方法运行结束之后,立刻出栈,局部变量就会立刻消失。
4.但是new出来的对象会在堆内存当中持续存在,直到垃圾回收消失。
12.4匿名内部类
如果接口的实现类(或者是父类的子类)只需要使用唯一的一次。那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。
匿名内部类的定义格式:
接口名称 对象名 = new 接口名称(){
//覆盖重写所有抽象方法
}
对格式“new 接口名称(){...}”进行解析:
1.new 代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口。
3.{...}这才是匿名内部类的内容
另外还要注意几点问题:
1.匿名内部类,在【创建对象】的时候,只能使用唯一一次。
如果希望多次创建对象,而且类的内容一样的话,那么久必须使用单独定义的实现类了。
2.匿名对象,在【调用方法】的时候,只能调用唯一一次。
如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
3.匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名称】
强调:匿名内部类和匿名对象不是一回事。
十六、File类
file类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法。
三个单词:
file 文件
directory 目录
path 路径
16.1分隔符
方法:
public String pathSeparator 路径分隔符 windows分号 ; Linux:冒号 :
public String separator 默认名称分隔符
16.2 file类的构造方法
a. File(String pathname) 通过将给定路径名字字符串转换为抽象路径名来创建一个新file实例。
参数:
String pathname:字符串的路径名称
路径可以是以文件结尾,也可以是以文件夹结尾。
路径可以是相对路径,也可以是绝对路径
路径可以是存在,也可以是不存在
创建File对象,只是把字符串路径封装为File对象,不考虑路径的真假情况。
b. File(File parent, String child) 根据parent抽象路径名和 child路径名字符串创建一个新File实例。
参数:分成了两个部分
File parent: 父路径
String child:子路径
好处:
父路径和子路径,可以单独书写,使用起来非常灵活;父路径和子路径都可以变化。
父路径是File类型,可以使用File的方法对路径进行一些操作,再使用路径创建对象。
16.3 File类获取功能的方法
public String getAbsolutePath() :返回此File的绝对路径名字符串
public String getPath() :将此File转换为路径字符串。
public String getName() :返回由此File表示的文件或目录的名称
public Long length() :返回由此File表示的文件的长度
16.4判断功能的方法
public boolean exists() :此File表示的文件或目录是否实际存在
public boolean isDirectory() :此File表示的是否为目录
public boolean isFile() :此File表示的是否为文件
16.5创建删除功能的方法
public boolean createNewFile() :当且仅当具有该名称的文件上不存在时,创建一个新的空文件。
public boolean delete() :删除由此File表示的文件或目录
public boolean mkdir() : 创建由此File表示的目录
public booean mkdirs() : 创建由此File表示的目录,包括任何必须但不存在的父目录。
16.6遍历(文件夹)目录的功能
public String[] list() : 返回一个String数组,表示该File目录中的所有子文件或目录
public File[] listFiles() : 返回一个File数组,表示该File目录中的所有子文件或目录
【注意】:
list方法和listFiles方法遍历的是构造方法中给出的目录
如果构造方法中给出的目录的路径不存在,会抛出空指针异常
如果构造方法中给出的路径不是一个目录,也会抛出空指针异常。