<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方法遍历的是构造方法中给出的目录

​ 如果构造方法中给出的目录的路径不存在,会抛出空指针异常

​ 如果构造方法中给出的路径不是一个目录,也会抛出空指针异常。

全部评论

相关推荐

评论
点赞
收藏
分享

创作者周榜

更多
牛客网
牛客网在线编程
牛客网题解
牛客企业服务