JAVA基础复习-CSDN博客

本文链接：https://blog.csdn.net/ZZR_ZZR_/article/details/120057319

title: JAVA基础复习
date: 2020/8/10

1. 数据类型

1.1 基本数据类型

byte ：1个字节

（byte num1 = 10）

short :2个字节

(short num2 = 20)

int ：4个字节

(int num3 = 30)

long ： 8个字节

(long num4 = 30L)

float ：4个字节

(float num5 = 50.1f)

double ：8个字节

(double num6 = 3.1415926)

char : 2个字节

（char name = '张'）

boolean : 1位（默认为false）

注：1字节（Byte）=8位（bit）

1.2 引用数据类型

类、接口、数组，默认初始化均为null

1.3 数据类型转换

由低到高

byte=short=char<int<long<float<double

低转换为高：自动转换

高转换为低：强制转换

2. 变量作用域

2.1 局部变量

存在于方法中，且必须声明和赋初值

2.2 实例变量

存在于方法外，类的里面，可以不用初始化值，除了8个基本类型（如String类型）默认是null，int类型默是0，布尔类型默认是false

3.3 类变量

加static，存在于方法外，类的里面，可以在方法中直接输出如

static int allClicks=0;

3. 常量

final double PI = 3.14

4. 变量的命名规范

见名知意

局部变量、类成员变量：首字母小写和驼峰原则，如monthSalary 除了第一个单词以外，后面的单词首字母大写

常量：所有字母大写和下划线

类名：首字母大写和驼峰原则

方法名：首字母小写和驼峰原则

5. 运算符

5.1 算数运算符

+，-，，/，%（取余），++（自增），–（自减）

5.2 赋值运算符

5.3 关系运算法

<，>，>=，<=，==，！=instanceof

5.4 逻辑运算符

&&，||，！

5.5 自增自减

int a = 3;

int b = a++; //执行完这行代码后，先给b赋值，再自增

//a = a+1; 

System.out.println(a);

//a = a+1;

int c =++a; //执行完这行代码前 ，先自增，再给b赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);
//结果：5,3,5

5.6 位运算符

A = 0011 1100
B = 0000 1101
-------------
A&B = 0000 1100
A|B = 0011 1101
A^B(异或：相同等于0，不同等于1) = 0011 0001
~B = 1111 0010

右移（>>）相当于 /2
左移（<<）相当于 *2
2<<3相当于2*(2*2*2)=16

6. 用户交互Scanner

public class test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数据：");
        String str = scanner.nextLine(); //把输入的整行打印
        System.out.println("输出的内容为："+str);
        scanner.close();
    }
}

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

        //输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
        Scanner scanner = new Scanner(System.in);
        int s = 10;
        int count = 0;
        System.out.println("请输入数字：");
        while(scanner.hasNextInt()){
            int i = scanner.nextInt();
            count = count+1;
            s = s+i;
            System.out.println("输入了"+count+"个数字");
        }
        System.out.println("总和为："+s);
        System.out.println("平均数为："+(s/count));
        scanner.close();
    }
}

switch多选择结构

switch (expression){
    case value :
        //语句
        break;
    case value :
        //语句
        break;
    default:
        //语句
}

注：switch语句中的变量类型可以是：String、byte、short、int或者char，且case标签必须为字符串常量或字面量

7. 方法的重载

7.1 定义

重载就是在一个类中，有相同的函数名称，但参数不同的函数；

7.2 方法重载的规则：

方法的名称必须相同；
参数列表必须不同（个数不同、类型不同或参数排列顺序不同等）
方法的返回类型可以相同也可以不相同
仅仅返回类型不同不足以成为方法的重载

8. 命令行窗口执行

1.编译生成`test.class`文件

javac test.java

2.运行

java test

9. 可变长参数

在方法声明中，在指定参数类型后加一个省略号（…），一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在它之前声明：

public void test(int... i);

10. 递归

递归就是自己调自己，用有限的语句来定义对象的无限集合：

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环；

递归题：什么时候需要调用自身方法。

11. 数组

int[] nums; //1.声明一个数组
nums = new int[10]; //2.创建一个数组  int[] nums = new int[10];
nums[0] = 1;  //3.给数组赋值
nums[0] = 2;
nums[0] = 3;
...
nums[10] = 10;
//若数组中某一个元素未被赋值，则默认为0
//数组长度是固定了，一旦确定就不能改变

11.1 三种初始化

1.静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

2.动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

3.数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化

11.2 数组的基本特点

其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
其元素必须是相同类型，不允许出现混合类型
数组的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

11.3 增强for循环

public void test1(){

    int[] arrays = {1,2,3,4,5};
    for(int array : arrays){
        System.out.println(array);
    }
}

12. Arrays类

数组的工具类java.util.Arrays，Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用

常用功能;

给数组赋值：fill方法

对数组排序：sort方法，按升序

比较数组：equals方法比较数组中元素值是否相等

查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

13. 冒泡排序

public static int[] sort(int[] array){
    int temp = 0;
    //外层循环，确定一共要判断几轮
    for(int i = 0;i<array.length-1;i++){
        //内层循环，比较判断两个数，把大的数和小的数互换位置
        for(int j = 0;j<array.length-1-i;j++){
            if(array[j]<array[j+1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    return array;
}

14. 静态方法调用

static存在于静态方法区，和了一起加载

public class test {

    public static void main(String[] args) {
        //静态方法调用，随着类一起加载，直接调用
        test.add(10, 20);

        //非静态方法调用，需要new对象，才能调用
        test test1 = new test();
        test1.de(40, 30); 
    }
   //静态方法
    public static int add(int a,int b){
        return a+b;
    }
    //非静态方法
    public int de(int a,int b){
        return a-b;
    }
}

15. 构造器

和类名相同，没有返回值

一个类即使什么都不写，它也会存在一个方法

一旦定义了有参构造，如果想使用无参构造，就必须显示定义无参构造

使用new关键字，本质是在调用构造器

16. 封装

16.1概念

封装，即数据的隐藏。通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。属性私有private，通过get/set方法访问。

16.2 作用

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加

17. 继承

在Java中，所有的类，都默认直接或者间接继承Object
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
Java中类只有单继承，没有多继承（一个儿子只能有一个爸爸，一个爸爸能有多个儿子）
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示
父类的私有private属性方法无法被继承
子类默认调用父类的无参构造器，通过super();且super()必须要在子类构造器的第一行
不能继承被final修饰的类

18.supper和this关键字

18.1 super注意点：

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

18.2 super和this对比：

代表的对象不同：

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

前提：

this：没有继承也可以使用
super：只能在继承条件才可以使用

构造方法：

this():本类的构造
super():父类的构造

19.方法重写

重写：需要有继承关系，子类重写父类的方法
重写方法名必须相同，子类重写的方法和父类必须一致，方法体不同
参数列表必须相同
修饰符：范围可以扩大但不能缩小：public>Protescted>Default>private
抛出的异常：范围，可以被缩小，但不能扩大
为什么需要重写：父类的功能，子类不一定需要，或者不一定满足
哪些方法不能被重写：

static方法，属于类，它不属于实例

final常量

private方法

20.多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型又很多
多态存在的条件：有继承关系，子类重写父类方法，父类引用指向子类对象
子类的引用变量指向子类对象时，子类能调用的方法都是自己的或者继承父类的

Student s1 = new Student();

父类的引用变量可以指向子类对象，但是不能调用子类独有的方法

Person s1 = new Student();   //其中，Person是Student的父类

子类若重写了父类的方法，则执行子类的方法

多态注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系，类型转换异常，ClassCastException
存在条件：继承关系，方法需要重写，父类引用指向子类对象

21. instanceof关键字

（类型转换）引用类型，判断一个对象是什么类型

System.out.println(x instanceof y);

若x和y存在父子关系，则编译通过

若x指向的实例类型是y 的子类型，则结果为true

22.类型转化

低转高,直接转换

//父（高）      < - 转         子（低）
Person obj = new Student();//其中，Person是Student的父类

高转低，强转

Student student = (Student)obj;

注：

父类引用指向子类的对象

把子类转换为父类，向上转型（直接转）

把父类转换为子类，向下转型（强制转换）

方便方法的调用，减少重复代码，更简洁

23. 抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
抽象类不能用new关键字来创建对象，它是用来让子类继承的
子类继承抽象类，那么就必须实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

24. 接口

接口不能被实例化，因为接口中没有构造方法接口都需要有实现类

接口中的所有定义的方法其实都是抽象的 public abstract，常量都是public static final

public abstract void add(String name);

实现类通过implements可同时继承多个接口，必须得重写接口中的方法

25. 内部类

public class test {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    //内部类
   public class Inner{
        //内部类的方法
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }

}

public class Application {
    public static void main(String[] args) {
        //创建一个外部类的对象
        test t1= new test();
        //通过外部类来实例化内部类
        test.Inner inner = t1.new Inner();
        //使用其方法
        inner.in();  //打印结果为“这是内部类的方法”
        inner.getID();  //打印结果为“10”
    }
}

局部内部类

public class test {

    //局部内部类
   public void method(){

       class Inner{
           public void in(){
               
           }
       }
   }
}

匿名内部类

public class test {

    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
    }
}


class Apple{
    public void eat(){
        System.out.println("1");
    }
}

26.异常Exception

Java把异常当中对象来处理，并定义一个基类java.lang.Trowable作为所有异常的超类

在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception

26.1 Error

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

Java虚拟机运行错误，当JVM不再继续执行操作所需的内存资源时，将出现OutOfMemoryError，JVM一般会选择线程终止

还有发生在虚拟机视图执行应用时，如类定义错误（NoClassDefFoundError）、连接错误（LinkageError）。

26.2 RuntimeException(运行时异常)

这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理，这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度避免这类异常的发生：

ArrayIndexOutOfBoundException（数组下标越界）

NullPointerException（控制住异常）

ArithmeticException(算术异常)

MissingResourceException(丢失资源)

ClassNotFoundException(找不到类)

26.3 Error和Exception的区别

Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

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

        int a = 1;
        int b = 0;

        //假设要捕获多个异常：从小到大  Throwable>Exception， 快捷键 ctrl+alt+T
        try{//try监控区域
            System.out.println(a/b);
        }catch (Error e){ //catch(想要捕获的异常类型)
            System.out.println("Error");
        }catch (Exception e){
            System.out.println("Exception");
        }catch (Throwable t){
            System.out.println("Throwable");
        } finally{//善后工作，无论怎样都会被执行，一般用于关闭IO资源
            System.out.println("finally");
        }
    }
}