Arrays类 冒泡排序 稀疏数组 面向对象编程 构造器 封装 继承 多态 instanceof static 异常机制
Arrays类
package base;
import java.util.Arrays;
public class Day39 {
public static void main(String[] args) {
int[] i1={9,8,7,6,5,4,3,2,1};
Arrays.sort(i1,3,5);//指定位置的排序
System.out.println(Arrays.toString(i1));
}
}
package base;
import java.util.Arrays;
public class Day39 {
public static void main(String[] args) {
int[] i1={9,8,7,6,5,4,3,2,1};
int[] i2={9,8,7,6,5,4,3,2,1};
int[] i3=Arrays.copyOf(i1,i1.length);
int[] i4=Arrays.copyOfRange(i1,2,i1.length);
int[] i5=new int[10];
int[] i6;
System.out.println(Arrays.equals(i1,i2));//deepEquals：比较二维数组内容是否相等
System.arraycopy(i1,0,i5,2,3);
i6=Arrays.copyOf(i5,i5.length);
Arrays.fill(i6,4,i6.length,2);//将一个数组全部置为 val ，或在下标范围内将数组置为 val
System.out.println("i3:"+Arrays.toString(i3));
System.out.println("i4:"+Arrays.toString(i4));
System.out.println("i5:"+Arrays.toString(i5));
System.out.println("i6:"+Arrays.toString(i6));
Arrays.sort(i3);
System.out.println(Arrays.binarySearch(i3,3));//binarySearch 二分法查找，数组必须有序，且存在此数组中，否则返回负数下标
Arrays.setAll(i3,x->i3[x]*2);
System.out.println(Arrays.toString(i3));
Arrays.parallelPrefix(i3,(x,y)->x*y);//二元迭代，对原数组内容进行二元操作
System.out.println(Arrays.toString(i3));
Arrays.parallelPrefix(i3,1,4,(x,y)->x*y);//二元迭代，对原数组指定位置的内容进行二元操作
System.out.println(Arrays.toString(i3));
}
}
/*
true
i3:[9, 8, 7, 6, 5, 4, 3, 2, 1]
i4:[7, 6, 5, 4, 3, 2, 1]
i5:[0, 0, 9, 8, 7, 0, 0, 0, 0, 0]
i6:[0, 0, 9, 8, 2, 2, 2, 2, 2, 2]
2
[2, 4, 6, 8, 10, 12, 14, 16, 18]
[2, 8, 48, 384, 3840, 46080, 645120, 10321920, 185794560]
[2, 8, 384, 147456, 3840, 46080, 645120, 10321920, 185794560]
进程已结束，退出代码 0
*/
冒泡排序
// 冒泡排序法
int[] i1={9,7,8,6,3,4,5,2,1,0};
int temp;
// 外层循环判断我们要走多少次
for (int i=0;i<i1.length-1;i++){
//内层循环，比较两个数
for(int j=0;j<i1.length-1-i;j++){
if(i1[j]>i1[j+1]){
temp=i1[j];
i1[j]=i1[j+1];
i1[j+1]=temp;
}
}
}
System.out.println(Arrays.toString(i1));
稀疏数组
{
//稀疏数组
int[][] i1=new int[11][11];
i1[1][2]=1;
i1[0][0]=2;
int nums=0;
int count=0;
// 输出
for (int[] i:i1){
for (int i2:i){
if (i2!=0)
nums++;
System.out.print(i2+"\t");
}
System.out.println();
}
// 转换为稀疏数组
System.out.println();
int[][] i2=new int[nums+1][3];
i2[0][0]=i1.length;
i2[0][1]=i1[0].length;
for (int i=0;i<i1.length;i++){
for (int j=0;j<i1[0].length;j++){
if(i1[i][j]!=0) {
count++;
i2[count][0] = i;
i2[count][1] = j;
i2[count][2] = i1[i][j];
}
}
}
for (int[] i:i2){
for (int i3:i) {
System.out.print(i3 + "\t");
}
System.out.println();
}
}
/*
2 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
11 11 0
0 0 2
1 2 1
*/
面向对象编程
- 本质：以类的方式组织代码，以对象的组织（封装）数据。
- 类是对象的抽象
创建与初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中的构造器调用。
- 类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。并且构造器有以下的两个特点
-
- 必须个类的名字相同
- 必须没有返回值类型，也不能写viod
构造器
- 实例化初始值
-
- 使用new关键字，本质是在调用构造器
- 用来初始化值
package oop;
public class Day39 {
static String name;
public Day39(String name){
this.name=name;//this.name是代表对象本身的name
}
}
package oop;
public class Test39 {
public Test39() {
}
public static void main(String[] args) {
System.out.println(new Day39("hhhhh").name);
}
}
//快捷键ALT+INS
封装
- 程序设计要追求“高内聚，低耦合”。高内聚就是类的年内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
- 封装（数据的隐藏）
-
- 通常，应禁止直接访问一个对象中数据的实际表面，而应该通过操作接口来访问。
- 提高程序的安全性，保护数据。
- 隐藏代码的实现细节。
- 统一接口
- 系统的可维护增加
继承
注意
- private修饰的不会继承给子类
- ctrl+h查看当前类的继承关系
- 默认调用父类的无参构造器
- super用于调用父类的属性和方法
方法的重写
- 静态方法和非静态方法的区别很大
-
- 静态方法:方法的调用只和左边定义的数据类型有关
- 非静态方法：重写
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以被扩大，但不能缩小；public>protected>default>private
- 抛出异常：范围可以被缩小，但不能扩大；
多态
- 多态是方法的多态，属性没有多态
- 父类和子类有联系，类型转换异常！ClasscastException
- 存在条件：继承关系，方法需要重写，父类的引用指向子类对象！
-
- static 方法，属于类，不属于实例
- final 常量
- private方法：不能被继承
instanceof和类型转换
//object->person->Teacher+student
person per=new student();
System.out.println(per instanceof student);//true
System.out.println(per instanceof person);
System.out.println(per instanceof object);
System.out.println(per instanceof teacher);//flase
System.out.println(per instanceof String);//编译出错
static
- 属于类，和类一起加载
- 非static要实例化之后才能使用
package oop;
import static java.lang.Math.random;//静态导入包
public class Test1{
{
System.out.println("匿名代码块");
}
static{
System.out.println("静态代码块");
}//只会被调用一次
public Test1() {
System.out.println("构造函数");
}
public static void main(String[] args) {
Test1 test=new Test1();
Test1 test1=new Test1();
System.out.println(random());
}
}
/*静态代码块
匿名代码块
构造函数
匿名代码块
构造函数
0.33911942073635515
*/
抽象类
- 不能new这个抽象类，只能靠子类去实现它
- 抽象类可以写普通方法
- 抽象方法必须写在抽象类中
- 存在构造器
接口
- 普通类：只有具体的实现
- 抽象类：具体实现和规范都有
- 接口：只有规范！约束和实现分离
- 约束
- 定义一些方法，让不同的人实现
- 方法是 public abstract
- 属性是public static final
- implement可以实现多个接口
- 必须要重写接口中的方法
异常机制
- 在Exception分支中有一个重要的子类RuntimeException
-
- ArrayIndexOutOfBoundsException（数组小标越界）
- NullPointerException（空指针异常）
- ArithmeticException（算数异常）
- MissingResourceException（丢失资源）
- ClassNotFoundException（找不到类）
- ClasscastException（类型转换异常）
int a=1;
int b=0;
try{//try监控区域
sout(a/b)
}catch(ArithmeticException e){//catch捕获异常（想要捕获的异常类型！）最高的异常类型是Throwable
sout("程序出现异常")
}finally{//处理善后工作
sout("finally")
}
//快捷键ctrl+alt+t
自定义异常
package oop;
public class Extention extends Exception {
private int i1;
public void myException(int a){
this.i1=a;
}
@Override
public String toString() {
return "Extention{" +
"i1=" + i1 +
'}';
}
}
package oop;
public class Test2 {
static void test(int a) throws Extention {
if(a>10){
throw new Extention();
}
}
public static void main(String[] args) {
try {
test(11);
} catch (Extention extention) {
extention.myException(11);
System.out.println("myException=>"+extention.toString());
}
}
}
//myException=>Extention{i1=11}