JAVA黑马培训整理笔记7-8-9-10-11-12

最新推荐文章于 2021-11-28 12:44:57 发布

秋雨行舟

最新推荐文章于 2021-11-28 12:44:57 发布

阅读量216

点赞数

分类专栏：编程语言学习

本文链接：https://blog.csdn.net/qq_38918049/article/details/102619482

版权

编程语言学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

day07【Scanner类、Random类、ArrayList类】

1.

Scanner sc = new Scanner(System.in); 
int i = sc.nextInt();

备注：System.in 系统输入指的是通过键盘录入数据。

2.匿名对象

概念：创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。应用场景非常有限。

匿名对象 ：没有变量名的对象。

格式：new 类名(参数列表)； 
举例：new Scanner(System.in)；

1.创建匿名对象直接调用方法，没有变量名： new Scanner(System.in).nextInt();

2. 一旦调用两次方法，就是创建了两个对象，造成浪费

3. 匿名对象可以作为方法的参数和返回值

3.获取随机数获取1-n之间的随机数，包含n，代码如下：

// 导包 
import java.util.Random; 
public class Test01Random { 
    public static void main(String[] args) { 
        int n = 50; 
        // 创建对象 
        Random r = new Random(); 
        // 获取随机数 
        int number = r.nextInt(n) + 1; 
        // 输出随机数 
        System.out.println("number:" + number); 
    } 
}

4.

基本格式：ArrayList<String> list = new ArrayList<>();

对于元素的操作,基本体现在——增、删、查。

list.add(e) ：将指定的元素添加到此集合的尾部。

list.remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。

list.get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。

list.size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

5.

基本类型基本类型包装类

byte Byte

short Short

int Integer

long Long

flfloat Float

double Double

char Character

boolean Boolean

只有Integer和Character需要特殊记忆，其他基本类型只是首字母大写即可。存储基本类型数据，代码如下： 
public class Demo02ArrayListMethod { 
    public static void main(String[] args) { 
        ArrayList<Integer> list = new ArrayList<>(); 
        list.add(1); 
        list.add(2); 
        list.add(3); 
        list.add(4); 
        System.out.println(list); 
    } 
}

day08【String类、static关键字、Arrays类、Math类】

1.String类

1. 字符串不变：字符串的值在创建后不能被更改。

// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

2. 因为String对象是不可变的，所以它们可以被共享。

// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

3. "abc" 等效于 char[] data={ 'a' , 'b' , 'c' } 。

// String底层是靠字符数组实现的。

2.

s1.equals(s2)：比较字符串的内容是否相同

(s1.equalsIgnoreCase(s2)：比较字符串的内容是否相同,忽略大小写

s.length()：获取字符串的长度，其实也就是字符个数

s.concat("**hello itheima")：将指定的字符串连接到该字符串的末尾.

s.charAt(0)：获取指定索引处的字符

s.indexOf("l")：获取str在字符串对象中第一次出现的索引,没有返回‐1

s.substring(0)：从start（0）开始截取字符串到字符串结尾

s.substring(3,8)：从start到end截取字符串。含start，不含end。

4.

char[] chs = s.toCharArray(); ：把字符串转换为字符数组

byte[] bytes = s.getBytes();：把字符串转换为字节数组

String replace = str.replace("it", "IT"); ：替换字母it为大写IT

String s = "aa|bb|cc";

String[] strArray = s.split("|"); ： ["aa","bb","cc"]

5.

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改

该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

static int numberID；

6.静态方法

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要

创建类的对象。

类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

public static void showNum() { 
    System.out.println("num:" + numberOfStudent); 
}

静态方法调用的注意事项：

静态方法可以直接访问类变量和静态方法。

静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。

静态方法中，不能使用this关键字。

小贴士：静态方法只能访问静态成员。

// 访问类变量

System.out.println(Student.numberOfStudent);

// 调用静态方法

Student.showNum();

7.

8.

静态代码块：定义在成员位置，使用static修饰的代码块{ }。

位置：类中方法外。

执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

格式：

public class ClassName{ 
    static { 
        // 执行语句 
    } 
}

9.

public static void main(String[] args) { 
    int[] arr = {2,34,35,4,657,8,69,9}; 
    String s = Arrays.toString(arr);  // 数组内容转为字符串 
    Arrays.sort(arr);  // 对数组进行排序
}

10.

Math.abs(‐5); ：返回绝对值

Math.ceil(3.3)；：向上取整

Math.floor(3.3); ：向下取整

Math.round(5.5); ：四舍五入

day09【继承、super、this、抽象类】

1.

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。

子类可以直接访问父类中的非私有的属性和行为。

class 父类 {

... }

class 子类 extends 父类 {

... }

2.

子父类中出现了同名的成员变量，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰

父类成员变量，类似于之前学过的 this 。

使用格式： super.父类成员变量名

3.

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效

果，也称为重写或者复写。声明不变，重新实现。

注意事项

1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

4.

构造方法的定义格式和作用。

1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。

2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构

造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代

5.

super和this的含义

super ：代表父类的存储空间标识(可以理解为父亲的引用)。

this ：代表当前对象的引用(谁调用就代表谁)。

访问成员

this.成员变量 ‐‐ 本类的

super.成员变量 ‐‐ 父类的

this.成员方法名() ‐‐ 本类的

super.成员方法名() ‐‐ 父类的

访问构造方法

this(...) ‐‐ 本类的构造方法

super(...) ‐‐ 父类的构造方法

6.

1. Java只支持单继承，不支持多继承。

2. Java支持多层继承(继承体系)。

3. 子类和父类是一种相对的概念。

7.抽象类定义

抽象方法 ：没有方法体的方法。

抽象类：包含抽象方法的类。

定义格式：修饰符 abstract 返回值类型方法名 (参数列表)；

代码举例： public abstract void run()；

抽象的使用：

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象

类。

day10【接口、多态】

1.接口定义格式

public interface 接口名称 {

// 抽象方法

// 默认方法

// 静态方法

// 私有方法 }

// 含有抽象方法
public interface InterFaceName { 
    public abstract void method(); 
} 
// 含有默认方法和静态方法
public interface InterFaceName { 
    public default void method() { 
        // 执行语句 
    }
    public static void method2() { 
        // 执行语句 
    } 
}
// 含有私有方法和私有静态方法
public interface InterFaceName { 
    private void method() { 
        // 执行语句 
    } 
}

2.

非抽象子类实现接口：

1. 必须重写接口中所有抽象方法。

2. 继承了接口的默认方法，即可以直接调用，也可以重写。

class 类名 implements 接口名 { 
    // 重写接口中抽象方法【必须】 
    // 重写接口中默认方法【可选】 
}

抽象方法的使用：必须全部实现

默认方法的使用：可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

静态方法的使用：静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用

私有方法的使用：

私有方法：只有默认方法可以调用。

私有静态方法：默认方法和静态方法可以调用。

3.接口的多实现

在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接

口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {

// 重写接口中抽象方法【必须】

// 重写接口中默认方法【不重名时可选】

}

4.

抽象方法：

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

默认方法：

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。

静态方法 :

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级的问题 :

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执

行父类的成员方法。

5.其他成员特点

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static fifinal修饰。

接口中，没有构造方法，不能创建对象。

接口中，没有静态代码块。

6.多态

多态：是指同一行为，具有多个不同表现形式。

1. 继承或者实现【二选一】

2. 方法的重写【意义体现：不重写，无意义】

3. 父类引用指向子类对象【格式体现】

多态体现的格式：

父类类型变量名 = new 子类对象；

变量名.方法名();

Fu f = new Zi();

f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，

如果没有，则编译错误；如果有，执行的是子类重写后方法。

7.引用类型转换

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

父类类型变量名 = new 子类类型();

如：Animal a = new Cat();

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

子类类型变量名 = (子类类型) 父类变量名;

如:Cat c =(Cat) a;

8.给引用变量做类型的校验：

变量名 instanceof 数据类型

如果变量属于该数据类型，返回true。

如果变量不属于该数据类型，返回false。

9.

在Java 9+版本中，接口的内容可以有：

1. 成员变量其实是常量，格式：
[public] [static] [final] 数据类型常量名称 = 数据值;
注意：
常量必须进行赋值，而且一旦赋值不能改变。
常量名称完全大写，用下划线进行分隔。

2. 接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型方法名称(参数列表);
注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

3. 从Java 8开始，接口里允许定义默认方法，格式：
[public] default 返回值类型方法名称(参数列表) { 方法体 }
注意：默认方法也可以被覆盖重写

4. 从Java 8开始，接口里允许定义静态方法，格式：
[public] static 返回值类型方法名称(参数列表) { 方法体 }
注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5. 从Java 9开始，接口里允许定义私有很乏，格式：
普通私有方法：private 返回值类型方法名称(参数列表) { 方法体 }
静态私有方法：private static 返回值类型方法名称(参数列表) { 方法体 }
注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

day11【fifinal、权限、内部类、引用类型】

1.final关键字

final：不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。

方法：被修饰的方法，不能被重写。

变量：被修饰的变量，不能被重新赋值。

2.

修饰类：格式如下：

final class 类名 {

}

修饰方法：格式如下：

修饰符 final 返回值类型方法名(参数列表){

//方法体

}

修饰变量：

1. 局部变量——基本类型

基本类型的局部变量，被fifinal修饰后，只能赋值一次，不能再更改。

2. 局部变量——引用类型

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能更改。但是不影响对象内部成员变量值的修改。

3. 成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

1.显示初始化；2.构造方法初始化。

3.权限修饰符

编写代码时，如果没有特殊的考虑，建议这样使用权限：

成员变量使用 private ，隐藏细节。

构造方法使用 public ，方便创建对象。

成员方法使用 public ，方便调用方法。

小贴士：不加权限修饰符，其访问能力与default修饰符相同

4.内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

成员内部类 ：定义在类中方法外的类。

class 外部类 {

class 内部类{

}

访问特点

内部类可以直接访问外部类的成员，包括私有成员。

外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式：

外部类名.内部类名对象名 = new 外部类型().new 内部类型()；

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名

和$符号。比如，Person$Heart.class

5.匿名内部类

匿名内部类必须继承一个父类或者实现一个父接口。

格式

new 父类名或者接口名(){

// 方法重写

@Override

public void method() {

// 执行语句

}

};

day12【Object类、常用API】

1.Object类

java.lang.Object类是Java语言中的根类，即所有类的父类。

它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

2. toString方法

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

// 如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：
public class Person {  
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    // 省略构造器与Getter Setter
}
// 在IntelliJ IDEA中，可以点击Code菜单中的Generate...，
// 也可以使用快捷键alt+insert，点击toString()选项。选择需要包含的成员变量并确定。

3.equals方法

public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

默认地址比较

如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

对象内容比较

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。

# 大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中，可以使用Code菜单中的Generate…选项，

# 也可以使用快捷键alt+insert，并选择equals() and hashCode()进行自动代码生成。

4.Objects类

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

public static boolean equals(Object a, Object b):判断两个对象是否相等。

5.Date类

Date类中的多数方法已经过时，常用的方法有：

public long getTime() 把日期对象转换成对应的时间毫秒值。

6.DateFormat类

java.text.DateFormat 是日期/时间格式化子类的抽象类，

我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

常用的格式规则为：

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档0。

DateFormat类的常用方法有：

public String format(Date date)：将Date对象格式化为字符串。
public Date parse(String source)：将字符串解析为Date对象。

// 使用format方法的代码为：
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date对象转换成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

// 使用parse方法的代码为：
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把String转换成Date对象
*/
public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}

7.Calendar类：有点麻烦，自己后面看看

8.System类

currentTimeMillis方法：

// 实际上，currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值
import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
       	//获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); // 1516090531144
    }
}

arraycopy方法：

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：
将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

// 将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，
// dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]
import java.util.Arrays;

public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代码运行后：两个数组中的元素发生了变化
         src数组元素[1,2,3,4,5]
         dest数组元素[1,2,3,9,10]
        */
    }
}

9.StringBuilder类

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。

StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

根据StringBuilder的API文档，常用构造方法有2个：

public StringBuilder()：构造一个空的StringBuilder容器。
public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

StringBuilder常用的方法有2个：

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象。

10.包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

装箱：从基本类型转换为对应的包装类对象。

拆箱：从包装类对象转换为对应的基本类型。

秋雨行舟

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
JAVA黑马培训整理笔记7-8-9-10-11-12

day07【Scanner类、Random类、ArrayList类】1.Scanner sc = new Scanner(System.in); int i = sc.nextInt();备注：System.in 系统输入指的是通过键盘录入数据。 2.匿名对象概念：创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。应用场景非常有限。匿名对象：没有变量名...
复制链接

扫一扫