Java基础重温巩固

方法

• 方法与方法之间是平级关系，不能嵌套
• return表示结束当前方法

基本数据类型和引用数据类型

基本数据类型：数据存储在自己的空间中

引用数据类型：数据存储在其他空间中，自己空间存储的是地址值

值传递

• 传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值

• 要有new才会有堆内存
• 引用类型，传递的是地址值，形参的改变，影响实际参数的值
  

自动拆装箱

• 装箱（boxing）：将 基本数据类型 转换成 包装类 。
• 拆箱（unboxing）：将 包装类 转换成 基本数据类型 。
• 自动装箱：将 基本数据类型 自动转换成 包装类 。
• 自动拆箱：将 包装类 自动转换成 基本数据类型 。

// 自动装箱
Integer num1 = 6;
// 自动拆箱
int num2 = num1;

this

1. this指向一个当前对象的引用，只能在对象内使用
2. 不能用于静态方法（this是一个对象层面的概念，不要与类层次概念混淆）
3. 在方法内部与局部变量与成员属性重名时，进行区分
4. 调用本类的构造方法
5. super调用父类的方法

重载

• 同一个类中方法名相同，参数不同的方法。与返回值无关

  • 参数不同，个数不同，类型不同，顺序不同

• java虚拟机会根据不同的参数来区分同名的方法

构造方法

• 可以有多个构造函数，但是需要重载

• 构造函数存在的意义，给初始值赋值
  

• 构造方法也叫构造器，构造函数

• 作用：创建对象给变量赋值，初始化

• 创建一次对象，构造方法就会被调用一次

特点:
1.方法名与类名相同，大小写也要一致
2.没有返回值类型，连void都没有
3.没有具体的返回值 (不能由retrun带回结果数据)

Java内存

成员变量和局部变量

内部类

1.什么是内部类?

• 写在一个类里面的类就叫做内部类

  2.什么时候用到内部类?

  • B类表示的事物是A类的一部分，且B单独存在没有意义比如: 汽车的发动机ArrayList的选代器人的心脏等等

• 内部类的分类

匿名内部类

• 为了避免一次调用就要创建一个类去继承父类
  
  
  

lambda表达式

• @FunctionalInterface接口加了这个注解不报错，就是函数式接口，可以使用lambda表达式
  
  
  

package com.liang.lambda;

import java.util.Arrays;
import java.util.Comparator;

public class lambdaDemo {
    public static void main(String[] args) {
        //lambda表达式
        Integer[] arr = {21,3,4,5,67,8,9};
//        Arrays.sort(arr, new Comparator<Integer>() {
//            @Override
//            public int compare(Integer o1, Integer o2) {
//                return o1-o2;
//            }
//        });
        //lambda完整格式
//        Arrays.sort(arr,(Integer o1, Integer o2)->{
//                return o1-o2;
//        });
        //lambda省略写法
        Arrays.sort(arr,( o1, o2)-> o1-o2);
        System.out.println(Arrays.toString(arr));
    }
}

this

• this就是找上级代码执行的内容

• 获取值就近原则

  

static

• static表示静态，是java中的一个修饰符，可以修饰成员方法，成员变量

• 静态变量是随着类的加载而加载的，优先于对象出现的

• 静态变量是类共享的，谁要用谁就拿
  
  

• 类.方法调用工具类

• 静态方法里面没有this，不能调用非静态的成员变量
• 非静态方法里面，有个隐藏的this
• 静态会存在堆内存

总结:

• 静态方法中没有this关键字。

• 静态方法中，只能访问静态。

• 非静态方法可以访问所有。

• 静态方法只能调用和访问静态
  

• 静态优先于对象加载

增强for遍历

• 修改增强for中的变量，不会改变集合中原本的数据
  
  
  

排序算法

冒泡排序

• 冒泡排序:相邻的数据两两比较，小的放前面，大的放后面

• idea批量改变字母，选中需要修改的字母shit+f6改成你对应的

    public static void main(String[] args) {
        //冒泡排序:相邻的数据两两比较，小的放前面，大的放后面
        int[]  arr = {1,5,4,2,3};
        //外循环: 表示我要执行多少轮如果有n个数据，那么执行n - 1 轮
        for (int i = 0; i < arr.length-1; i++) {//0 1 2 3
            //内循环: 每一轮中我如何比较数据并找到当前的最大值
            // -1: 为了防止索引越界
           //-i: 提高效率，每一轮执行的次数应该比上一轮少一次
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

    }

选择排序

• 从0索引开始，拿着每一个索引上的元素跟后面的元素依次比较小的放前面，大的放后面，以此类推。
  

    public static void main(String[] args) {

//        选择排序:
//        1，从@索引开始，跟后面的元素一一比较。
//        2，小的放前面，大的放后面。
//        3，第一次循环结束后，最小的数据已经确定
//        4，第二次循环从1索引开始以此类推。

        //选择排序
        int[]  arr = {10,5,4,2,3};

        //最终代码:
        //外循环: 几轮
        //i:表示这一轮中，我拿着哪个索引上的数据跟后面的数据进行比较并交换
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");

        }
    }