java基础(数组、面向抽象编程、static、异常)-编程思维

数组

  • 相同的数据类型的数据集合
  • 按照一定的先后次序排列组合
  • 通过下标来访问他们

声明---创建

  • 建议 String[] a;
  • String a [];//c 和c++才有不专业
String [] a =new int [10];
a[i]--取值

数组的默认初始化

  • 数组是引用类型,他的元素相当于类的实例变量,因此数组一经过分配空间,其中的每个元素也按照实例变量同样的方式被隐藏初始化
  • 静态初始化::栈
  • 动态初始化::栈和堆

基本特点:

  • 数组的长度是确定的
  • 元素必须是相同的类型
  • 数组的元素可以是任何的数据类型
  • 数组变量属于引用类型
  • 数组本身是对象,java的对象是在堆中的,数组对象是在堆中的
  • 下标的合法区间[0,n-1]
  • 数组也是对象,数组的元素属于成员变量
  • 数组的长度是确定的,不可变,不能越界

数组的使用:

int[] a ={1,2,3,4,5};
//打印全部的数组元素
for(int i-0;i<a.length;i++){
    syso.(a[i]);
}
//计算所有元素的和
int sun=0;
for(int i-0;i<a.length;i++){
    //sum=sun+a[i]
    sun+=a[i];
}
//查找最大值
int max=arry[0];
for(int i-1;i<a.length;i++){
    if(array[i]>max){
        max=array[i];
    }
}
//增强的for循环  但是取不到下标
for(int array :a){
    syso(a);
}
//反转数组
int[] result new int[a.length];
for(int i-1;j<result.length;i<a.length;i++;j--){
 	result[j]=a[i];
}

多维数组:

int[][] a={{1,2,3},{1,2,3},{1,2,3}};
遍历
for(int i=0;i<a.length;i++){
    for(int j=0;j<a[i].length;j++){
        syso.(a[i[j]]);
    }
}

对象Arrays

java.util.arrays

int[] a ={1,2,3,4,5};

static修饰可以直接用

  • 打印数组的元素
Arrays.toString(a);
  • 排序
Arrays.sort(a);//升序
  • 赋值
fill方法
Arrays.fill(a,0);
  • 比较
比较equals方法  //比较数组的元素是否相等
  • 查找
binarySearch能对排序好的查找进行二分查找

稀疏数组

  • 记录数组一共有几行几列,有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小的规模的数组中,从而缩小小程序的规模
int[][] array =new int[11][11];
array[1][5]=10;
array[5][5]=5;
//获得有效值的个数
int sum =0;
for(int i=0;i<array.length;i++){
    for(int j=0;j<array[i].length;i++){
        if(array[i][j]!=0){
            sum++;
        }
    }
}
//创建稀疏数组
int [][]array2 =new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
//遍历二位数组,将非零的值存放在数组中
int count =0;
for(int i=0;i<array.length;i++){
    fro(int j =0;j<array[i].length;j++){
        if(array[i][j]!=0){
            count++;
            array2[count][0]=i;
            array2[count][1]=j;
            array2[count][2]=array[i][j];
        }
    }
}

八种排序算法

  • 冒泡排序 O(n2)
for(int i=0;i<array.length-1;i++){
    for(int j=0;j<array.length-i;j++){
        if(array[j+1]>array[j]){
            temp=array[j];
            array[j]=array[j+1];
            array[j+1]=temp;
        }
    }
}
  • 选择排序
for(int i =0;i<arr.length-1;i++){
    for(int j=i+1;j<arr.length;j++){
        if(arr[i]>arr[j]){
            int tem = arr[i];
            arr[i]=arr[j];
            arr[j]=tem;
        }
    }
}
  • 二分查找(前提是拍好序列)

内存分析

  • new的对象
  • 数组
  • 可以被所有的线程所共享的,不会存放别的对象的引用

  • 存放基本的变量类型
  • 引用的对象的变量

方法区

  • 可以被所有的线程共享
  • 包含了所有的clss和static变量

面向对象编程

oop

对于描述复杂的事物,为了从宏观上把握,从整体上合理的分析,我们需要使用面向对象的思想来分析整个系统。但是在微观操作上,仍然需要面向过程的思想去处理

本质:已类的方式组织代码,已对象的组织(封装数据)

特征:

  • 封装
  • 继承
  • 多态

方法的调用、值传递、类和对象的关系

类是一种抽象的数据类型,但是不能表示一种具体的事物

对象是抽象的概念的具体实例

new 创建对象

类:

  • 属性
  • 方法

抽象的类要实例化

构造方法:

  • 必须和类的名字相同
  • 必须没有返回值

new的内存分析:

。。。。

封装:

  • 属性私有,get/set

高内聚,低耦合

继承

java类中只有单继承,没有多继承

extends

  • 继承是类和类之间的关系,类之间的关系好友依赖,组合,聚合
  • 继承是两个类的关系 源生类 派生类
  • 子类和父类之间有is a关系
  • Object
  • super
  • 方法的重写

Super方法

super.父类的方法直接写就行了

this当前类的

调用构造器只能在第一行

默认调用父类的构造器

如果父类没有无参的构造,子类也无法写无参的构造

子类的代码会隐藏父类的无参的构造

注意

  • super调用父类的构造方法,必须在构造方法的第一个
  • super必需只能出现在子类的方法或者构造方法中
  • super和this不能同时使用

前提:

  • this本身调用者这个对象
  • super:代表父类对象的应用

构造方法:

  • this()本身的构造
  • super父类的构造

重写@Override

  • 非静态的
  • 私有的不行
  • 方法名必须相同
  • 参数列表相同
  • 修饰符可以扩大
  • 重写可能会抛出异常,异常可以缩小不能扩大

public》protected》Default》private

多态

动态编译

interface implements

存在的条件:

  • 有继承关系
  • 子类重写父类的方法
  • 父类的引用指向子类对象

父类的应用指向子类

B b =new A();

class A extends B;

注意事项:

  • 多态是方法的多态,属性没有多态
  • 父类和子类,有联系 类型转换异常ClassCastException
  • 存在条件。。。。。前面有

方法要被重写--多态:

不能重写的

  • static属于类,不属于实例
  • final 修饰的无法 在常量池内
  • private修饰的

instanceof 判断一个数据的类型

x instanceof y;

x和y之间是否有父子关系

类型转换,子类的方法要类型转换。

子类----父类 ---向上转型

父类---子类------强制转换

Static

private static int a;//多线程
private int b;

静态变量在一个特别的区里面;

public static run(){

}
public go(){
    
}
  • 静态方法只能静态方法
  • 静态方法随着类加载生成
  • 可以直接使用(静态代码块)

静态代码块static{}------匿名代码块{}-----构造方法

静态导入包

import static java.lang.PI;

被final定义的类不能被继承----断子绝孙

抽象类

abstract:

抽象类的子类要实现抽象类的所有的方法;

extends

但是是单继承

  • 不能new抽象类,只能那子类去实现它:约束
  • 抽象类里面可以放普通方法
  • 抽象方法必须放在抽象类里面

接口

interface implements

  • 只有规范,面向接口编程

接口的本质是契约

接口的方法都是public abstratact 的

  • 类实现接口必学实现接口中的方法
  • 接口里面的变量是常量public static final

接口不能实例化,没有构造方法

内部类

  • 成员内部类
  • 静态内部类
  • 局部变量
  • 匿名内部类
public Class outer{
    private int id;
    public void out(){
        syso(“外部类”)
    }
    //内部类可以获得外部类的私有属性和方法
    public class Inner{
        public void in(){
		syso("内部类");
}
    }
}
//内部类
Outer out =new Outer();
Outer.Innter  inner= out.new Inner();

静态内部类:

public Class outer{
    private int id;
    public void out(){
        syso(“外部类”)
    }
    //内部类可以获得外部类的私有属性和方法
    public static class Inner{
        public void in(){
		syso("内部类");
            //这里就拿不到外部类的变量的值了,静态内部类无法访问静态方法
}
    }
}

局部内部类:

在方法里面写内部类:

public Class outer{
    private int id;
    public void out(){
        syso(“外部类”)
            public class Inner{
        public void in(){
		syso("内部类");
}
    }
    }
}

一个java里面可以写多个class类

class a{}
class b{}

匿名内部类:

接口 a = new 接口(){
    @Override
    方法
}

Error和Exception

  • 异常是指运行中出现不预期的各种状况
  • 异常发生在程序运行期间,他影响了正常的执行流程

异常分为:

  • 检查性异常
  • 运行时异常
  • 错误Error

java.lang.Throwable 超类

  • ArrayLndexOutOfBoundsException 数组线标越界
  • NullPointerExceotion空指针异常
  • ArithmeticException算数异常
  • MissingResourceException 丢失资源
  • ClassNotFountException找不到类等异常

抛出异常:

捕获异常

关键字:

try catch finally throw throws

throw new ArithmeticException();//抛出一个异常
//一般在方法中使用,加入这个方法处理不了这个异常,就抛出异常
public void a throws ....

自定义异常

public ex extends Exception{
    //传递数字》10
    private int detail;
    public ex (int a){
        this.detail = a;
    }
    @Override
    public String toString(){
	return "myex{"+detail+"}";
}
}
throw new ex();

版权声明:本文版权归作者所有,遵循 CC 4.0 BY-SA 许可协议, 转载请注明原文链接
https://www.cnblogs.com/HJZ114152/p/16406695.html