数组
一、一维数组
1.一维数组的声明与初始化
正确的方式:
int num;//声明
num = 10;//初始化
int id = 1001;//声明 + 初始化
int[] ids;//声明
//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004};
//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
int[] arr4 = {1,2,3,4,5};//类型推断
错误的方式:
int[] arr1 = new int[];
int[5] arr2 = new int[5];
int[] arr3 = new int[3]{1,2,3};
2.一维数组元素的引用: 通过角标的方式调用。
数组的角标(或索引从0开始的,到数组的长度-1结束。
3.数组的属性:length
说明:
数组一旦初始化,其长度就是确定的。arr.length
数组长度一旦确定,就不可修改。
4.一维数组的遍历
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
5.一维数组元素的默认初始化值
数组元素是整型:0
数组元素是浮点型:0.0
数组元素是char型:0或’\u0000’,而非’0’
数组元素是boolean型:false
数组元素是引用数据类型:null
二、二维数组
正确的方式:
int[] arr = new int[]{1,2,3};//一维数组
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//也是正确的写法:
int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断
错误的方式:
String[][] arr4 = new String[][4];
String[4][3] arr5 = new String[][];
int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
遍历二维数组元素
for(int i = 0;i < arr4.length;i++){
for(int j = 0;j < arr4[i].length;j++){
System.out.print(arr4[i][j] + " ");
}
System.out.println();
}
3.Arrays工具类的使用
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binarySearch(int[] a,int key)
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
if(index >= 0){
System.out.println(index);
}else{
System.out.println("未找到");
}
4.数组的常见异常
- 1.数组角标越界异常:ArrayIndexOutOfBoundsException
- 2.空指针异常:NullPointerException
面向对象
类与对象
1.面向对象学习的三条主线:
- 1.Java类及类的成员:属性、方法、构造器;代码块、内部类
- 2.面向对象的大特征:封装性、继承性、多态性、(抽象性)
- 3.其它关键字:this、super、static、final、abstract、interface、package、import等
2.面向对象与面向过程(理解)
- 1.面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做。
- 2.面向对象:强调具备了功能的对象,以类/对象为最小单位,考虑谁来做。
类的结构之一:属性
对比:属性 和 局部变量
1.相同点:
1.1 定义变量的格式:数据类型 变量名 = 变量值
1.2 先声明,后使用
1.3 变量都其对应的作用域
2.不同点:
2.1 在类中声明的位置的不同
属性:直接定义在类的一对{}内 局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
** 2.2 关于权限修饰符的不同**
属性:可以在声明属性时,指明其权限,使用权限修饰符。 常用的权限修饰符:private、public、缺省、protected --->封装性 局部变量:不可以使用权限修饰符。
2.3 默认初始化值的情况:
属性:类的属性,根据其类型,都默认初始化值。 整型(byte、short、int、long:0) 浮点型(float、double:0.0) 字符型(char:0 (或'\u0000')) 布尔型(boolean:false) 引用数据类型(类、数组、接口:null) 局部变量:没默认初始化值。 意味着,我们在调用局部变量之前,一定要显式赋值。 特别地:形参在调用时,我们赋值即可。
2.4 在内存中加载的位置:
属性:加载到堆空间中 (非static) 局部变量:加载到栈空间
类的结构之二:方法
方法的声明:权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
说明
返回值类型: 返回值 : 没返回值
- 如果方法返回值,则必须在方法声明时,指定返回值的类型。同时,方法中,需要使用
return关键字来返回指定类型的变量或常量:“return 数据”。 -
如果方法没返回值,则方法声明时,使用void来表示。通常,没返回值的方法中,就不需要 使用return.但是,如果使用的话,只能“return;”表示结束此方法的意思。
类的结构之三:构造器
1.构造器(或构造方法): Constructor
构造器的作用:
- 1.创建对象
- 2.初始化对象的信息
2.使用说明:
- 1.如果没显式的定义类的构造器的话,则系统默认提供一个空参的构造器
- 2.定义构造器的格式:权限修饰符 类名(形参列表){}
- 3.一个类中定义的多个构造器,彼此构成重载
- 4.一旦我们显式的定义了类的构造器之后,系统就不再提供默认的空参构造器
- 5.一个类中,至少会有一个构造器。
类的结构之四:代码块
1.代码块的作用:
用来初始化类、对象的信息
2.分类:
代码块要是使用修饰符,只能使用static
3.静态代码块 : 非静态代码块
静态代码块:
内部可以输出语句
随着类的加载而执行,而且只执行一次
作用:初始化类的信息
如果一个类中定义了多个静态代码块,则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法,不能调用非静态的结构
非静态代码块:
内部可以输出语句
随着对象的创建而执行
每创建一个对象,就执行一次非静态代码块
作用:可以在创建对象时,对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块,则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法,或非静态的属性、非静态的方法
类的结构之五:内部类
1.定义: Java中允许将一个类A声明在另一个类B中,则类A就是内部类,类B称为外部类.
2.成员内部类(静态、非静态 ) :
成员内部类的理解:
一方面,作为外部类的成员:
调用外部类的结构
可以被static修饰
可以被4种不同的权限修饰
另一方面,作为一个类:
类内可以定义属性、方法、构造器等
可以被final修饰,表示此类不能被继承。言外之意,不使用final,就可以被继承
可以被abstract修饰
2.1如何创建成员内部类的对象?(静态的,非静态的)
//创建静态的Dog内部类的实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();
//创建非静态的Bird内部类的实例(非静态的成员内部类):
//Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();
2.2如何在成员内部类中调用外部类的结构?
class Person{
String name = "小明";
public void eat(){
}
//非静态成员内部类
class Bird{
String name = "杜鹃";
public void display(String name){
System.out.println(name);//方法的形参
System.out.println(this.name);//内部类的属性
System.out.println(Person.this.name);//外部类的属性
//Person.this.eat();
}
}
}
面向对象特征之一: 封装性
1.Java规定的四种权限修饰符
1.1 权限从小到大顺序为: private < 缺省 < protected < public
1.2 具体的修饰范围:
面向对象特征之二: 继承性
1.继承性的格式:
class A extends B{ }
- A:子类、派生类、subclass
- B:父类、超类、基类、superclass
2.Java中继承性的说明
- 1.一个类可以被多个子类继承。
- 2.Java中类的单继承性:一个类只能有一个父类
- 3.子父类是相对的概念。
- 4.子类直接继承的父类,称为:直接父类。间接继承的父类称为:间接父类
- 5.子类继承父类以后,就获取了直接父类以及所间接父类中声明的属性和方法
面向对象特征之三: 多态性
1.多态性的使用前提:
① 类的继承关系
② 方法的重写
关键字
this
1.可以调用的结构: 属性、方法;构造器
2.this调用属性、方法:
this理解为: 当前对象 或 当前正在创建的对象
-
2.1 在类的方法中,我们可以使用"this.属性"或"this.方法"的方式,调用当前对象属性或方法。但是,通常情况下,我们都择省略"this."。特殊情况下,如果方法的形参和类的属性同名时,我们必须显式 的使用"this.变量"的方式,表明此变量是属性,而非形参。
-
2.2 在类的构造器中,我们可以使用"this.属性"或"this.方法"的方式,调用当前正在创建的对象属性或方法。但是,通常情况下,我们都择省略"this."。特殊情况下,如果构造器的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。
3.this调用构造器:
① 我们在类的构造器中,可以显式的使用"this(形参列表)"方式,调用本类中指定的其他构造器
② 构造器中不能通过"this(形参列表)“方式调用自己
③ 如果一个类中有n个构造器,则最多有 n - 1构造器中使用了"this(形参列表)”
④ 规定:"this(形参列表)“必须声明在当前构造器的首行
⑤ 构造器内部,最多只能声明一个"this(形参列表)”,用来调用其他的构造器
super
1.super 关键字可以理解为: 父类的
2.可以用来调用的结构:
属性、方法、构造器
3.super调用属性、方法:
- 3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式,显式的调用父类中声明的属性或方法。但是,通常情况下,我们习惯省略"super."
- 3.2 特殊情况:当子类和父类中定义了同名的属性时,我们要想在子类中调用父类中声明的属性,则必须显式的使用"super.属性"的方式,表明调用的是父类中声明的属性。
- 3.3 特殊情况:当子类重写了父类中的方法以后,我们想在子类的方法中调用父类中被重写的方法时,则必须显式的使用"super.方法"的方式,表明调用的是父类中被重写的方法。
4.super调用构造器:
- 4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器
- 4.2 "super(形参列表)"的使用,必须声明在子类构造器的首行!
- 4.3 我们在类的构造器中,针对于"this(形参列表)"或"super(形参列表)"只能二一,不能同时出现
- 4.4 在构造器的首行,没显式的声明"this(形参列表)“或"super(形参列表)”,则默认调用的是父类中空参的构造器:super()
- 4.5 在类的多个构造器中,至少一个类的构造器中使用了"super(形参列表)",调用父类中的构造器
后续…