JAVA SE基础笔记(三)

7 数组

7.1 数组概述

数组是相同类型数据的有序集合

可以通过下标来访问,下标从0开始

7.2 数组创建

声明创建

首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法:

dataType[] arrayRefVar; // 首选的方法

dataType arrayRefVar[]; // 效果相同,但不是首选方法

Java语言使用new操作符来创建数组,语法如下:

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事:

  1. 使用 dataType[arraySize] 创建了一个数组。
  2. 把新创建的数组的引用赋值给变量 arrayRefVar。

当然也可以使用一行代码完成声明和创建:

int[] numbers = new int[100];

可以通过numbers.length获取长度

初始化

有三种初始化

  • 静态初始化:

    int[] numbers = {1,2,3};
    Person[] people = {new Person(),new Person()};
    
  • 动态初始化:包含默认初始化

    int[] numbers = new int[10];
    b[0] = 1;
    
  • 默认初始化:数组是引用类型,其中的元素相当于类的实例变量,因此数组一经分配空间,其中的元素就按照实例变量同样的方式被隐式初始化。

内存分析

Java内存分为:

  • 堆:存放new的对象和数组
  • 栈:存放基本变量类型,包括具体数值。存放引用对象的变量,包括具体地址。
  • 方法区:包含所有class和static变量,方法区是特殊的堆。

声明数组时,数组并不存在,只是在栈中压入一个变量

创建数组时,数组才会存在,在堆中真正地开辟出空间

下标越界

访问下标超出数组大小会产生下标越界异常。

基本特点

  • 长度确定
  • 相同类型
  • 元素可以是任意的类型
  • 数组是引用类型,数组可以看成是对象,Java中的对象保存在堆中,无论数组对象中存什么数据类型,数组所占空间是在堆中的,返回的引用是在栈里的。引用:栈--->堆

7.3 数组使用

  • 使用for循环
  • 使用for-each循环即增强型for
  • 使用数组作为方法的参数
  • 使用数组作为返回值

7.4 多维数组

数组的元素还是数组

int[][] nums = new int[2][5];
int[][] numbers = {{1,2},{3,4},{5,6}};

7.5 Arrays类

数组的工具类java.util.Arrays

Arrays类中的方法都是static修饰的静态方法,可以直接使用类名调用

有以下常用功能

  • 给数组赋值:通过 fill 方法。
  • 对数组排序:通过 sort 方法,按升序。
  • 比较数组:通过 equals 方法比较数组中元素值是否相等。
  • 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

7.6 冒泡排序

public static void sort(int[] array){
	for(int i=0;i<array.length-1;i++){
        
        boolean flag = false;//优化,跳过没有意义的比较轮次
        
        //减i是因为进行i次比较后,产生了i个最大或最小的数不需要进行下次比较
        for(int j=0;j<array.length-1-i;j++){
            if(array[j+1]<array[j])
                swap(array[j+1],array[j]);
        }
        if(flag == flase)
            break;
    }
}

7.7 稀疏数组

数组中大部分为0,或其他相同元素时,采用的一种压缩存储方式。

即只记录数组行列等基本信息,以及有效信息

8 面向对象

8.1 初识面向对象

面向过程

面向对象

以类的方式组织代码,以对象的方式封装数据

8.2 方法

回顾:如何定义方法

静态方法:可以通过类名调用

非静态方法:需要实例化对象,借用对象调用

形参实参

值传递引用传递

this关键字:用来表示当前对象本身,或当前类的一个实例,通过 this 可以调用本对象的所有方法和属性。

8.3 对象创建分析

使用new创建对象,创建时会

  • 分配内存空间
  • 默认初始化
  • 调用构造方法

构造方法

  • 方法名和类名相同
  • 没有返回类型,不能写成void

一旦定义了有参构造,无参构造就必须显式定义

new本质是在调用构造器

内存分析

JAVA SE基础笔记(三)

8.4 三大特性

封装

高内聚,低耦合

  • 模块内部联系紧密
  • 模块之间联系松散

封装:数据的隐藏,将数据封装起来,只暴露给外界接口

属性:private

方法:getter/setter

封装的优点:

  • 良好的封装能够减少耦合。
  • 类内部的结构可以*修改。
  • 可以对成员变量进行更精确的控制。
  • 隐藏信息,实现细节。

继承

继承是类于类之间的关系,除此之外类与类之间的关系还有依赖,组合,聚合。继承:is a关系

Java只有单继承

控制访问与继承的规则

  • 父类中声明为 public 的方法在子类中也必须为 public。
  • 父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。
  • 父类中声明为 private 的方法,不能够被继承。

Object类

在Java中,所有的类都继承了Object类

super关键字:表示当前类的父类

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

一般在写了带参数构造器后,都需要显式写出无参构造器

方法重写

重写是方法的重写与属性无关

静态方法:方法调用只和定义时的类有关,其实是通过类名在调用

非静态方法:重写,用实例化对象调用

父类

public class A {
    public static void test_static(){
        System.out.println("A=>test_static");
    }

    public void test(){
        System.out.println("A=>test");
    }
}

子类

public class B extends A{
    public static void test_static(){
        System.out.println("B=>test_static");
    }

    @Override
    public void test(){
        System.out.println("B=>test");
    }
}

测试

public class test {
    public static void main(String[] args) {

        B b = new B();
        A a= new B();

        b.test_static();
        a.test_static();

        a.test();
        b.test();
    }
}

输出

B=>test_static
A=>test_static
B=>test
B=>test

总结

  • 重写需要有继承关系,子类重写父类的关系
  • 方法名相同
  • 参数列表相同
  • 修饰符:范围可以扩大但不能缩小
    • 父类是protected子类改为public
  • 异常:可以缩小但不能扩大
    • 父类是Exception子类是ClassNotFoundException

不能重写的方法

  • static方法属于类,不属于实例
  • final修饰的方法
  • private 私有的方法无法重写

不能继承的类

  • 被final修饰的类

多态

动态编译:类型在执行时才能确定

同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的

但可以指向的引用类型就不一定了,父类引用可以指向子类的对象

父类

public class Person {
    public void run(){
        System.out.println("run");
    }
}

子类

public class Student extends Person{
    public void eat(){
        System.out.println("eat");
    }

    @Override
    public void run() {
        System.out.println("sonRun");;
    }
}

测试

public class Test {
    public static void main(String[] args) {

        Student s1 = new Student();
        Person s2 = new Student();

        s1.run();//两个类型都有run方法且子类重写,执行子类的
        s2.run();

        s1.eat();//eat方法是子类独有的,父类无法调用
        //s2.eat();//报错
    }
}

输出

sonRun
sonRun
eat

总结:

多态是方法的多态,属性没有多态

多态存在条件:

  1. 有继承关系
  2. 子类重写父类的方法
  3. 父类引用指向子类对象

多态的实现可以有以下几种:

  1. 重写
  2. 接口
  3. 抽象类和抽象方法

8.5 instanceof

判断一个类型是不是某种类型

A instanceof B

看A和B有没有继承关系,

同级别类是无法通过编译的

8.6 类型转换

引用类型转换

同样的高转低要强制转换

低转高是直接实现可以的

如果子类转为父类就可能会丢失一些子类自己本来的方法

子类转父类 向上转型

父类转子类 向下转型 强制转换

8.7 static

static变量

static变量也称作静态变量,静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本【存放在方法区】,它当且仅当在类初次加载时会被初始化【加final和不加final的static变量初始化的位置不一样】。而非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。

static方法

static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

static静态代码块

static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方,类中可以有多个static块。在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次【根据class加载原理 每个类加载一次 使用双亲委托加载】。

初始化的顺序 静态代码块 > 构造代码块 > 构造函数

测试

public class Test {
    {
        System.out.println("匿名代码块");
    }

    static{
        System.out.println("静态代码块");
    }

    public Test(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Test test = new Test();
        System.out.println("=========");
        Test test2 = new Test();
    }
}

执行

静态代码块
匿名代码块
构造方法
=========
匿名代码块
构造方法

static块可以用来优化程序性能,是因为它的特性:只会在类加载的时候执行一次,之后会按匿名代码块,构造方法的顺序执行

很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

静态内部类

​ pass

静态导包

import static java.lang.Math.random;//下面使用时可以直接调用random()

8.8 抽象类

abstract修饰符可以修饰方法也可以修饰类,abstract修饰方法就是抽象方法,abstract修饰类就是抽象类。

抽象类中可以没有抽象方法,但是一旦定义的抽象方法就必须声明为抽象类。抽象类也可以写普通方法。

抽象类:不能实例化,不能new,它就是用来让别人继承的

抽象方法:只有方法的声明,没有实现,子类需要实现。

子类继承抽象类就需要实现抽象方法,否则它也应当声明为抽象类


但是抽象类本质还是一个类,别人需要用extends继承,但是Java只有单继承

这是需要引入接口,接口可以实现多继承

思考:抽象类也存在构造器

8.9 接口

接口:只有规范。可以实现约束和实现分离--->面向接口编程

接口就是规范,定义的是一组规则。体现的是现实世界中“如果你是...则必须能...”的思想

接口的本质是契约,像法律,制定好了大家都要遵守

面向对象的精髓,是对对象的抽象,最能体现这一点的就是接口。

设计模式其实就是在研究:如何合理地去抽象


接口中定义方法都是抽象的,而且默认是public abstract,可以不写

接口中定义的属性都是常量,默认public static final,一般没人在接口里定义属性

使用接口时要注意锻炼自己的抽象思维能力

总结

  1. 接口是约束
  2. 接口定义一些方法,让不同的人实现
  3. 接口方法默认是public abstract
  4. 接口属性默认是public static final
  5. 接口不能被实例化,接口也没有构造方法
  6. implements可以实现多个接口

8.10 内部类

内部类就是在类的内部再定义一个类

一个java类可以有多个class,但只能有一个public class

  • 成员内部类

  • 静态内部类

  • 局部内部类

  • 匿名内部类

9 异常

什么是异常

程序运行时出现的不期而至的情况,文件找不到,网络链接失败等

要理解Java异常处理是如何工作的,你需要掌握以下三种类型的异常:

  • 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
  • 运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
  • 错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。

异常体系结构

所有的异常类是从 java.lang.Exception 类继承的子类。

Exception 类是 Throwable 类的子类。除了Exception类外,Throwable还有一个子类Error 。

Java 程序通常不捕获错误。错误一般发生在严重故障时,它们在Java程序处理的范畴之外。

Error 用来指示运行时环境发生的错误。

例如,JVM 内存溢出。一般地,程序不会从错误中恢复。

异常类有两个主要的子类:IOException 类和 RuntimeException 类。

        Throwable Exception Error IOException RuntimeException

Error

Error类对象由Java虚拟机生成并抛出,大多数错误与代码编写者执行的操作无关。

Error是灾难性的致命的错误,是程序无法控制和处理的

Exception

Exception通常是可以被程序处理的。我们应当尽量避免一些异常的产生。

捕获和抛出异常

抛出异常

捕获异常

五个关键字

try,catch,finally,throw,throws

主动抛出异常

一般在方法中使用。

if(b == 0){
	throw new ArithmeticException();
}

在方法上抛出异常throws

public void method(int a,int b) throws IOException{
    }

自定义异常

在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

  • 所有异常都必须是 Throwable 的子类。
  • 如果希望写一个检查性异常类,则需要继承 Exception 类。
  • 如果你想写一个运行时异常类,那么需要继承 RuntimeException 类。

可以像下面这样定义自己的异常类:

class MyException extends Exception{
    }

实例

public class MyException extends Exception
{
  private int number;
  public MyException(int number)
  {
    this.number = number;
  } 
  @Override
  public String toString(){
  	return "MyException: "+number;
  }
}



##转载,仅供自己学习##
上一篇:linux基础之初识linux及常用命令


下一篇:PHP大文件上传进度条插件