首页 > 代码库 > java基础3
java基础3
1.二维数组
定义：元素为一维数组的数组。
动态初始化方式一（指定有多少个长度相同的一维数组）：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示有多少个一维数组
n表示一维数组中有多少个元素
动态初始化方式二（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：
数据类型[][] 变量名 = new 数据类型[m][];
注：m这个数据必须给出，后面的数据可以不给
二维数组的静态初始化
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
public class arrayarraydemo {
// 二维数组的遍历
public static void main(String[] args) {
// 定义一个静态数组
int [][]arr1={{1,2},{1,2,3},{21,4,5},{23,45,5}};
// 定义一个含有三个一维数组的二维数组，一维数组有4个元素
int [][]arr=new int[3][4];
// 定义一个含有三个一维数组的数组
int [][]arr2=new int[3][];
showarray(arr1);
} public static void showarray(int arr1[][]){
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[i].length; j++) {
System.out.print(arr1[i][j]+" ");
}
}
}
}2.形式参数问题
如果形式参数是基本类型：
形式参数的改变，不影响实际参数。
如果形式参数是引用类型：
形式参数的改变，直接影响实际参序。
3 .冒泡排序
基本规则：相邻两个比较，大的放后面第一次排序完毕最大的元素在索引最大处，依此类推。
代码实现
public class bubblesort { public static void main(String[] args) {
int []a={1,223,34,532,64,8,56};
bubbleSort(a);
printArray(a);
} public static void bubbleSort(int[] a){
//冒泡排序方法，外层循环控制大的轮回，内层循环进行相邻两个元素比较把大的在
//后面第一次轮回结束最大的元素在最后一位。
for (int i = 0; i < a.length-1; i++) {
for (int j = 0; j < a.length-1-i; j++) {
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
[j+1]=temp;
}
}
}
} //构造一个遍历数组的方法
public static void printArray(int[] a){
System.out.print("[");
for (int i = 0; i < a.length; i++) {
if(i==a.length-1){
System.out.print(a[i]);
} else{
System.out.print(a[i]+",");
}
}
System.out.println("]");
}
}3.选择排序
基本规则：从0索引处开始依次与后面的比较，第一次结束后最小的位于0索引处，依次进行
代码实现
public class selectSort {
public static void main(String[] args) {
int []arr={1,24,5,34,6,367,434,378};
printArray(arr);
}
//选择排序
public static void selectSort(int []arr){
//使用两个for循环嵌套，假设i为最小数，用它跟数组中其他元素比较，
//如果有比他小的就交换位置
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length; j++) { if(arr[i]>arr[j]){ int temp=arr[i];
arr[i]=arr[j];
arr[j]=arr[i];
}
}
}
}
//写一个遍历数组的方法
public static void printArray(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
System.out.print(arr[i]);
}else{
System.out.print(arr[i]+",");
}
System.out.print("]");
}
}4.Arrays数组工具类
针对数组进行操作的工具类。提供了排序，转换等功能。
成员方法：
public static String toString(int[] a):把数组转成字符串
public static void sort(int[] a):对数组进行排序（有重载）
5.继承
extends关键字可以进行类与类之间的继承
格式：
class 子类名 extends 父类名 {
} 父类：基类，超类 子类：派生类 学生类： 成员变量：name,age 构造方法：无参,带参 成员方法：getXxx()/setXxx(),eat(),sleep() 老师类： 成员变量：name,age 构造方法：无参,带参 成员方法：getXxx()/setXxx(),eat(),sleep() 按照我们刚才对继承的概述，我们可以找一个父类。 人类： 成员变量：name,age 构造方法：无参,带参 成员方法：getXxx()/setXxx(),eat(),sleep() 学生类：继承人类就可以了。 老师类：继承人类就可以了。 继承的好处： A:提高了代码的复用性 多个类相同的成员可以放到同一个类中 B:提高了代码的维护性 如果功能的代码需要修改，修改一处即可 C:让类与类之间产生了关系，是多态的前提 方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)： 1.必须存在继承关系 2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能 继承的特点：（代码演示） A:Java只支持单继承，不支持多继承。 B:Java支持多层(重)继承(继承体系)。 什么时候使用继承呢? 继承中类之间体现的是：”is a”的关系。就是子类必须是父类的对象。 举例：水果，香蕉 举例：水杯，水果 (不能采用继承。) 举例：动物，狗
6.类的组成：
成员变量
构造方法
成员方法
继承间的成员变量关系： A:名字不同，非常简单。 B:名字相同 首先在子类局部范围找 然后在子类成员范围找 最后在父类成员范围找(肯定不能访问到父类局部范围) 如果还是没有就报错。(仅能在父类找） 就近原则。
super
关键字
可以调用父类的方法
super:
super代表父类存储空间的标识(可以理解为父类对象)
this和super的使用区别： A:成员变量 this.成员变量 本类的成员变量 super.成员变量 父类的成员变量 B:成员方法 this.成员方法() 本类的成员方法 super.成员方法()父类的成员方法 继承间构造方法的关系： 子类中所有的构造方法默认都会访问父类中空参数的构造方法(super()) 因为子类会继承父类中的数据，可能还会使用父类的数据。 所以，子类初始化之前，一定要先完成父类数据的初始化。 每个子类的构造方法的第一行，有一条默认的语句: super(); 注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。 假如父类没有无参构造方法,该怎么办呢? A:调用父类的其他构造方法。带参构造。 怎么访问呢? super(...) 注意： super(…)或者this(….)必须出现在第一条语句上。 因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。 建议： 永远给出无参构造方法。
7.final关键字
在实际开发的时候，有些方法的内容一旦写定后，就不允许被改动。
即使是子类，也不允许。
Java为了解决这样的问题就提供了一个关键字：final
最终的意思。它可以修饰类,方法,变量。
特点：
修饰方法，方法不能被重写。
修饰类，类不能被继承。
修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。
常量： A:字面值常量 ‘a‘,12,"hello" B:自定义常量 就是把变量用final修饰。 定义一个常量。 final 数据类型 变量名;
8.多态
定义：同一个对象,在不同时刻表现出来的不同状态。
多态的前提：
A:有继承关系
B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）
C:有父类引用指向子类对象
成员访问特点
A:成员变量
编译看左边,运行看左边
B:构造方法
子类构造默认访问父类的无参构造
C:成员方法（重点理解）
编译看左边,运行看右边
为什么变量和方法不一样呢? 方法重写。 D:静态成员方法 编译看左边,运行看左边 因为静态的内容是和类相关的，与对象无关。
9.抽象类
抽象类特点:
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
C:抽象类不能实例化
实例化并使用
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
D:抽象类的子类
要么是抽象类
，要么重写抽象类中的所有抽象方法
抽象类的作用： 强制要求子类必须要重写某些方法。 类的组成： 成员变量： 构造方法： 成员方法： 抽象类的成员： 成员变量：可以是变量，也可以是常量。 构造方法：有构造方法 构造方法作用：用于子类访问父类数据的初始化。 成员方法：既可以是抽象的，也可以是非抽象的。
抽象类练习
以后我们在写代码的时候，有这样的分析过程。
分析：
从具体到抽象。
实现：
从抽象到具体。
使用：
使用具体的类。
java基础3