JAVA基础总结

JAVA基础知识点总结

一、基础部分

  1. 命名规范

    • 变量，方法，类名要见名知意

    • 类成员变量首字符小写，驼峰命名法

    • 局部变量：首字母小写，驼峰命名法

    • 类名：首字符大写，驼峰命名法

    • 方法名：首字母小写，驼峰命名法

    • 包名全部小写，类首字符大写

    • 常量全部大写，用下划线分隔

  2. 常量在编译期就要确定值

  3. 三高问题：高可用，高性能，高并发

  4. JAVA特性

    • 简单性
    • 面向对象
    • 可移植性
    • 高性能
    • 分布式
    • 动态性
    • 多线程
    • 安全性
    • 健壮性

  5. java运行原理

    1. 编写代码

    2. javac java文件 -->class文件

    3. 运行class文件

  6. 编程语言运行机制

    1. 编译（compile）
      • c++,c,操作系统
    2. 解释
      • python

  7. Java数据类型

    • 基本数据类型
      • 数值型
        1. 整形：byte，short,int ,long
        2. 浮点型:float,double
        3. 字符型:char
      • 布尔型:boolean
    • 引用类型：类，接口，数组

    注意：

    1. 一般long类型的数后加L

    2. float类型后加F

    3. 所有的字符本质为数字

    2**16=65536，a=97,A=65

  8. 类型转换

    低--------------------------------------------------------------------高

    byte，short，char->int->long->float->double

    • 强制类型转换：高--低
    • 自动转换:低-----高

    注意：

    1. 不能对布尔转换
    2. 不能把类型转换为不相干的类型
    3. 转换可能出现内存溢出或者精度问题

  9. JDK7新特性，数字之间可以用下划线分割 如：100_00_00

  10. Java是强类型语言，每个变量必须声明其类型

  11. 变量三要素：变量名，变量类型，作用域

  12. 变量作用域：

    • 局部变量：在成员方法内部定义的变量，必须声明初始化值
    • 实例变量（成员变量）：从属于对象，如果不自行初始化，为这个类型的默认值
      • 布尔值默认为false
      • 除基本类型外，其他都为null
      • 数值型默认值为0
    • 类变量（static）：从属于类

  13. 常量：初始化后不再改变

    变量的规律：变量类型前都是修饰符，修饰符不存在先后顺序

  14. 运算符

    • 算数运算符：+ - * / % ++ --
    • 赋值：==
    • 关系：> < >= <= == != instanceof
    • 逻辑：&& || ！
    • 位：& | ^(异或) ~（取反）<< >>>
    • 条件：？ ：
    • 扩展赋值：+= -= *= /=
    进行算数运算时，有long的结果为long,有double的结果为double，short+byte(其他)=int

  15. ++ -- 为一元运算符（可以单独运算，区别于+、-）

  16. 幂运算：Math.pow(2,3) ==>2**3=8

  17. 逻辑与：两真为真

    逻辑或：有真为真

  18. 加号两侧，一方出现String，把其他转化为String后连接

  19. JavaDoc命令用来生成自己的Api文档

    1. @author作者名
    2. @version版本号
    3. @Since知名最早使用的jdk版本
    4. @param参数名
    5. @return返回值
    6. @throws异常抛出

  20. JAVA流程控制

    1. Jdk5新特性，scanner获取用户输入
    Scanner scan=new Sanner(System.in);

    1. 凡是属于Io流的类，要即使关掉流

      scan.close();

    2. next():

      1. 必须输入值
      2. 有空格，自动去除
      3. next不能带有空格

    3. nextlint():

      返回回车前的所有字符

21、打印99乘法表

       //打印99乘法表
        for (int j = 1; j <=9 ; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(j + "*" + i + "=" + (j * i)+" ");
            }
            System.out.println();
        }

  1. break跳出循环，continue跳出本次循环

  2. 质数：大于1的自然数中，除了1和它本身以外不再有其他因数的自然数

  3. 打印101-105之间的质数

    public static void main(String[] args) {
    int count = 0;
    outer: for (int i = 101; i < 150; i ++) {
        for (int j = 2; j < i / 2; j++) {
            if (i % j == 0)
                continue outer;
        }
        System.out.print(i+ "  ");
    }
}

  4. 计算0-100之间的奇数和，偶数和

    public static void main(String[] args) {
    int oddSum = 0;  //用来保存奇数的和
    int evenSum = 0;  //用来存放偶数的和
    for(int i=0;i<=100;i++){
        if(i%2!=0){
            oddSum += i;
        }else{
            evenSum += i;
        }

    }
    System.out.println("奇数的和："+oddSum);
    System.out.println("偶数的和："+evenSum);
}

  5. 用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

    public static void main(String[] args) {
    for(int j = 1;j<=1000;j++){
        if(j%5==0){
            System.out.print(j+"\t");
        }
        if(j%(5*3)==0){
            System.out.println();
        }
    }
}

  6. 重载：在同一个类中，相同函数名，参数不同

    • 规则：方法名必须相同
    • 参数列表必须不同（个数，类型，排列顺序）
    • 方法返回值类型可以想通，可以不同
    • 在同一个勒种

  7. 可变参数（...）

    • 在参数类型后+省略号
    • 一个方法只能指定一个可变参数，必须是方法的最后一个参数
    • 任何普通参数必须在它之后申明

  8. 递归(自己调用自己)

    • 递归头：什么时候不能调用自身的方法（如果没有递归头，则陷入死循环）

    • 递归体：什么时候调用自身的方法（阶乘）

      • public static void main(String[] args) {
    System.out.println(f(5));
}

public static int f(int n) {
    if (1 == n)
        return 1;
    else
        return n*f(n-1);
}

二、数组

数组的定义

  • 数组是相同类型数据的有序集合
  • 数组表述的是相同类型若干数据，按照一定先后顺序组合
  • 每一个数据称为一个数组元素，每个数组元素可以通过下标来访问

数组的四个基本特点：

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

数组三大初始化：

  • 静态初始化：int[] a=[1,2,3]
  • 动态初始化：int[]a=new int[10]
  • 默认：数组为引用类型，数组一经初始化分配空间，被隐式初始化

arrays.sort()：排序（升序）

三、内存分析

  1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法
  2. 声明一个数组的时候并没有数组被真正的创建。
  3. 构造一个数组，必须指定长度

四、排序算法

冒泡排序算法的原理：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的
    数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
class Bubble {
    public int[] sort(int[] array) {
        int temp = 0;
        // 外层循环，它决定一共走几趟 //-1为了防止溢出
        for (int i = 0; i < array.length - 1; i++) {
            int flag = 0; //通过符号位可以减少无谓的比较，如果已经有序了，就退出循环
            //内层循环，它决定每趟走一次
            for (int j = 0; j < array.length - i - 1; j++) {
                //如果后一个大于前一个,则换位
                if (array[j + 1] > array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = 1;
                }
            }
            if (flag == 0) {
                break;
            }
        }
        return array;
    }

    public static void main(String[] args) {
        Bubble bubble = new Bubble();
        int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] sort = bubble.sort(array);
        for (int num : sort) {
            System.out.print(num + "\t");
        }
    }
}

选择排序算法的原理：

  • 是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
class SelectSort{
    public int[] sort(int arr[]) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {// 认为目前的数就是最小的, 记录最小数的下标
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]) {// 修改最小值的下标
                    minIndex = j;
                }
            }// 当退出for就找到这次的最小值,就需要交换位置了
            if (i != minIndex) {//交换当前值和找到的最小值的位置
                temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        SelectSort selectSort = new SelectSort();
        int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] sort = selectSort.sort(array);
        for (int num : sort) {
            System.out.print(num + "\t");
        }
    }
}

五、面向对象

  • break结束方法，返回一个结果
  • 一旦定义有参构造，必定以无参构造

1. 构造器

  • 和类名相同
  • 无返回值

构造器作用:

  1. new本质为调用构造方法
  2. 初始化对象的值（alt+insert)

2.三大特性

2.1 封装

  1. 优点：
    • 提高安全性，保护数据
    • 隐藏代码实现细节
    • 统一接口
    • 可维护性增强

2.2继承（ctrl+h继承树）

  • 调用父类构造器必须放在第一行
  • 方法的调用只和左边的数据类型有关
2.2.1方法重写
  • 方法名相同
  • 参数列表相同
  • 范围可以扩大，不能缩小
  • 抛出异常可以缩小，不能扩大

2.3多态

多态特征

  • 多态是方法的多态，属性没有多态
  • 父类子类有联系
  • 存在继承关系，方法要重写
  • 父类引用指向子类

不可重写的情况

  • static属于类，不属于实例，静态方法不可重写
  • final修饰不可重写
  • private修饰不可重写

tips:

  • 父类引用指向子类，不能调用子类独有的方法（对象能执行哪些方法，主要看左边的类型）

多态的条件

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

instanceof判断两个类是否存在父子关系

补充

  1. 父类引用指向子类对象
  2. 把子类转为父类，向上转型
  3. 父--子，向下转型（强制类型转换）
  4. 方便方法调用，减少重复代码

六、static关键字

  • 非静态可访问静态方法
  • 静态方法只能调用静态方法，不可以调用普通方法

代码块，静态代码块执行顺序

  1. 静态代码块
  2. 匿名代码块
  3. 构造方法

七、抽象类

  1. 抽象方法，只写方法名，不用实现
  2. 抽象类所有的方法,继承了它的子类必须实现它的方法
  3. 如果子类是抽象类，name交给子子类

注意

  1. 抽象类不能new,只能靠子类实现
  2. 抽象方法必须在抽象类中
  3. 抽象类可以写普通的方法

八、接口

定义：只有规范，约束和实现分离，面向接口编程

  • 接口中所有的定义默认是抽象的
  • 可实现多个接口，用 “ ，” 隔开

注意：

  • 约束
  • 定义方法，让不同的人实现
  • 接口不能被实例化
posted @ 2020-02-15 13:15  梦想与爱  阅读(166)  评论(0)  编辑  收藏  举报