Java基础学习小结

Java基础学习小结

八大基本数据类型

分别有： 整数型byte ， short ， int，long四种，浮点数float，double两种 ， 字符char和布尔类型 boolean。其中float类型定义时要在数字后加上F。在使用浮点数进行比较时，传递的字符是有限的，存在舍入误差和精度问题，最好完全使用浮点数进行比较。所有的字符本质上还是数字。

整数拓展：

二进制用 0b 表示，八进制用 0 表示，十六进制用 0x 表示。

强制转换和自动转换：

从高到低转换需要强制转换，不过要考虑到内存溢出和精度问题。反之则为自动转换。
注意点：
1.不能对布尔值进行转换；
2.不能把对象转换为不相干的类型；
3.转换时可能存在内存溢出或者精度问题；

变量

类变量：static ，这个静态代码块只会被执行一次，别人都可以调用。
实例变量：从属于对象；如果不自行实例化，这个类型的默认值为0 0.0；
局部变量：必须声明和初始化值

修饰符

修饰符：修饰符不存在先后顺序 static public；

运算符

多个数计算时其中有long类型，则结果也为long类型，如果没有则为int类型；double同理；关系运算符的返回结果为布尔值。
逻辑运算符： 与（and） 或（or） 非（取反）
&&：两个变量都为真时结果为真，否则为假；
||：两个变量只要有一个为真，结果就为真；
!(a)：当a为真时结果为假，当a为假时结果为真；
三元运算符：x ？y : z 如果x==true，则结果为y ，否则结果为z；

扫描器 Scanner

使用.next()接收：
1.一定要读取到有效字符才会结束；
2.对输入有效字符前的空白，next（）会自动将其去掉；
3.只有输入有效字符后才将后面的空白作为分隔符或者结束符；
使用 .nextLine()接收：
1.以Enter作为结束符，nextLine(）方法返回的是输入回车之前的所有字符；
2.可以获得空白；
使用完scanner如果不关闭会一直占用资源，scanner.close（）;

练习

输入多个数字，并求其总和与平均数，每输入一个数字用回车确认 通过输入非数字来结束并输出执行结果

Scanner scanner= new Scanner(System.in);
        // 和
        double sum = 0;
        // 计算输入了多少个数字
        int m = 0 ;
        // 通过while循环判断是否还在输入，并在里面对每一次进行求和和统计
        while (scanner.hasNextDouble()){
            double d = scanner.nextFloat();
            m = m +1 ;
            sum = sum +d;
            System.out.println("你输入了第"+m+"个数据，当前的和为："+sum);
       }
        System.out.println(m+"个数据的和为："+sum);
        System.out.println(m+"个数据的平均值为："+sum/m);

        scanner.close();
    }

构造

break和continue

break的作用为强行终止循环；continue的作用为跳过某一次循环；
break：
1.break在任何循环语句的主体部分，均可用break控制循环流程；
2.break用于强制退出循环，不执行循环中剩余的语句（break也可在switch语句中使用）；
continue：continue语句在循环语句中，用于终止某一次循环过程，即跳过这次循环体中尚未执行的语句，接着进行下一次是否执行循环的判定；

while和dowhile

while先判断再赋值，do while先赋值再判断；

switch

case有穿透性，后面要接break；

 switch (grade){
            case 'A':
                System.out.println("优秀");
                break;// case后面要加break
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("中等");
                break;
            case 'D':
                System.out.println("差");
                break;
                default:
                    System.out.println("未知");
                    

For循环

for（初始化值；条件判断；迭代）{}

 // 分别计算0~100之间的奇数和偶数的和
        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);

标签的用法

 // 打印101~150之间的所有质数
       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+" ");

方法

递归算法

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

数组

一维数组 array[ ] 和多维数组 array[ [ ] ，[ ] ]
创建一个数组：变量类型 变量名字 = new 变量的值；
静态初始化：创建 + 赋值；动态初始化：包括默认初始化，不赋值；
冒泡排序：
1.比较数组中两个相邻的元素，如果第一个数比第二个大，就交换位置；
2.每一次比较，都会产生出一个最大或者最小的数字；
3.下一轮则可以少循环一次；
4.依次循环，直到结束！

稀疏数组：

   public static void main(String[] args) {
        // 创建一个二维数组
        int[][] array1= new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        System.out.println("输出原始数组");

        for (int[] ints: array1){
            for (int  anInt :ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        // 转换为稀疏数组保存
        // 获取有效值的个数

        int sum = 0;
        for (int i = 0; i <11 ; i++) {
            for (int j = 0; j <11 ; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效个数："+sum);

        // 创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2 [0][0]=11;
        array2 [0][1]=11;
        array2 [0][2]=sum;

        //遍历二维数组，将非零的值，存放到稀疏数组中
        int c =0;
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1[i].length ; j++) {
                if (array1[i][j]!=0){
                    c++;
                    array2[c][0]=i;
                    array2[c][1]=j;
                    array2[c][2]=array1[i][j];

                }

            }
        }
            // 输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }

        System.out.println("还原");
        // 1.读取稀疏数组
        int[][]array3= new int [array2[0][0]] [array2[0][1]];

        // 2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] =array2[i][2];

        }
        // 3.打印
        System.out.println("输出还原的数组");
        for (int[] ints:array1){
            for (int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

面向对象编程 oop

类：抽象的 需要实例化；类实例化后会返回一个自己的对象；一个类即使什么都不写，也会存在一个方法。
实例化初始值
1.使用new关键字，本质是在调用构造器；
2.用来初始化值；

有参构造: 一旦定义了有参构造，无参构造必须显示定义；
无参构造：创建 不赋值具体的值；
private的好处：私有的
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统的可维护性增加了

super Vs this

super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须在能出现在子类的方法或者构造方法中
3.super和this 不能同时调用构造方法
比较 this：
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的引用
前提
this：没有继承也可以使用
super：只能在继承条件下才可以使用
构造方法
this(); 本类的构造
super(); 父类的构造

重写

重写：需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩public>protected>default>private

4.抛出的异常：范围，可以被缩小，但不能被扩大；ClassBorFoundException - ->Exception(大)

重写，子类方法和父类方法相同，方法体不同

为什么需要重写：
父类的功能，子类不一定需要，或者不一定满足

多态

多态的注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new son();

不能被重写的方法：
1.static方法，属于类，他不属于实例
2.final 常量
3.private方法：私有的

接口

接口作用：
1.约束
2.定义一些方法，让不同的人实现 完成同一个事
3.public abstract
4.public static final 常量
5.接口不能被实例化 接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法