JavaSE-Java基础知识点笔记

最新推荐文章于 2022-11-13 21:13:55 发布

键.

最新推荐文章于 2022-11-13 21:13:55 发布

阅读量152

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/beekim/article/details/114767204

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

基础语法

1，标识符和关键字

关键字：

标识符：

2，数据类型

强类型语言：

要求变量的使用要严格符合规定，所有变量都必须先定义后使用

弱类型语言：

js，vb等

字节：

3，数据类型拓展

public class demo01 {
    public static void main(String[] args) {
        //整数扩展： 进制 二进制 0b 十进制 八进制 0 十六进制 0x
        int i =10;
        int i2= 010;
        int i3=0x10;
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("========================================");

        //浮点数扩展 银行业务怎么表示？钱
        //BigDecimal 类

        //float  有限 离散 舍入误差 大约 接近但不等于

        //double
    //最好完全使用浮点数进行比较



        float f=01.f;
        double d=1.0/10;
        System.out.println(f==d);

        float f1=4521456546454646f;
        float f2=f1+1;
        System.out.println(f1==f2);

        System.out.println("=======================================");
        //字符扩展
        char c1='a';
        char c2='中';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);//强制转换
        //所有的字符本质还是数字
        //编码 Unicode 表 ：（97=a 65=A） 2字节  0-65535  EXCEL 2 16 =65536
        //U0000 UFFFF
        char c3='\u0061';
        System.out.println(c3);//  a

        //转移字符

        //\t 制表符
        // \n 换行

 //布尔值扩展
        boolean flag=true;
        if (flag){
            System.out.println("true");
        }

    }
}

4，类型转换

低------------------------------------------>高

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

public class demo02 {

    public static void main(String[] args) {
        int i=128;
        byte b=(byte) i;
        //强制转换 （类型）变量名 高--低
        //自动转换   低--高

        System.out.println(i);
        System.out.println(b);
        /**
         * 低------------------------------------------>高
         * byte,short,char->int->long->float->double
         * 注意点：
         * 1，不能对布尔值进行转换
         * 2，不能把对象类型转换为不相干的类型
         * 3，在把高容量转换到低容量的时候，强制转换
         * 4，转换的时候可能崔仔内存溢出，或者精度问题！
         */
        System.out.println("===================");
        System.out.println((int)23.7); //23
        System.out.println((int)-45.29f);//-45
        System.out.println("=======================");
        char c='a';
        int d = c+1;
        System.out.println(d);
        System.out.println((char) d);

    }
}

import java.time.Year;

public class demo03 {


    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        // jdk7新特新，数字之间可以用下划线分割
        int money=10_0000_0000;
        int years=20;
        int total=money*years;
        System.out.println(total);//-1474836480 溢出
        long total2=money*years;//默认是int ，转换之前已经出现了问题
        System.out.println(total2);
        long t3=money*((long)years);
        System.out.println(t3);
    }
}

5，变量

6，运算符

位运算：

字符串连接符：

7，javadoc

流程控制

1，scanner

package scanner;

import java.util.Scanner;

public class demo01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("使用next方式接受：");
        if(scanner.hasNext()){
            String str =scanner.next();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

package scanner;

import java.util.Scanner;

public class demo02 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("使用nextline方式接受：");

        if (scanner.hasNextLine()){
            String str=scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

package scanner;

import java.util.Scanner;

public class demo03 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int i=0;
        float f=0.0f;

        System.out.println("请输入整数：");
        if(scanner.hasNextInt()){
            i=scanner.nextInt();
            System.out.println("整数数据："+i);
        }
        else{
            System.out.println("输入的不是整数数据！");
        }
scanner.close();
    }
}

package scanner;

import java.util.Scanner;

public class demo04 {
    public static void main(String[] args) {
       Scanner scanner= new Scanner(System.in);
       double sum=0;
       int m=0;
        System.out.println("输入一组数据：");
       while (scanner.hasNextDouble())
       {
           double x=scanner.nextDouble();
           m++;
           sum+=x;
           System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
       }
        System.out.println(m+"个数的和为："+sum);
        System.out.println(m+"个数的平均值是："+(sum/m));
        scanner.close();
    }
}

2，顺序结构

3，选择结构

九九乘法表：

package Forwhile;

public class JJBSY9981 {
    public static void main(String[] args) {
        for (int j = 1; j <=9; j++) {
            for (int i = 1; i <=j; i++) {
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();
        }


    }
}

增强for循环

4，break，continue

打印三角形

package Forwhile;

public class Sanjiao {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <=i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

方法

1，什么是方法？

2，方法的定义与调用

3，方法的重载

4，可变参数

5，递归调用

数组

1，数组声明和创建

2，内存分析

3，三种初始化

4，数组使用

package arrays;

public class UserArray {
    public static void main(String[] args) {
        int [] arrays={1,2,3,4,5};
        //打印全部数组元素

        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("================");
        //计算所有元素的和
        int sum=0;
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];

        }
        System.out.println(sum);
        System.out.println("================");
        //查找最大元素
        int max=arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i]>max)
                max=arrays[i];

        }
        System.out.println("max:"+max);
    }
}

package arrays;

public class Use2 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};

        //foreach
//        for (int array:arrays) {
//            System.out.println(array);
//        }

      //  printArray(arrays);

        int[] reverse= reverse(arrays);
       printArray(reverse);
    }
    //打印数组元素，数组作为方法入参
    public  static  void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]+" ");
        }
    }
    //数组作返回值，翻转数组
    public  static  int[]  reverse(int[] array){
        int[] result=new int[array.length];
        //反转操作
        for (int i=0,j=result.length-1;i<array.length;i++,j--){
            result[j]=array[i];
        }
        return result;
    }
}

5，二维数组

6，Arrays类

package arrays;

import java.util.Arrays;

public class Use3 {
    public static void main(String[] args) {
        int[] a={12,4,6,85,2,45,51};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

7，冒泡排序

package arrays;

import java.util.Arrays;

public class Use4 {
    public static void main(String[] args) {
        //冒泡排序
        /**
         * 1,比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置
         * 2,每一次比较都会产生出一个最大或者最小的数字
         * 3,下一轮则可以少一次排序
         * 4,依次循环知道结束
         */
            int [] a={52,4,22,15,3,6,8,54,55,221};
            int [] sort=sort(a);
            System.out.println(Arrays.toString(sort));


    }
    public static  int[] sort(int[] array){
        //临时变量
        int t=0;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length; i++) {
            //内层循环，比较判断两个数，如果第一个数比第二个数打，则交换位置
            for (int j = 0; j < array.length-1; j++) {
                if (array[j+1]>array[j])
                {
                    t=array[j];
                    array[j]=array[j+1];
                    array[j+1]=t;
                }
            }
        }
        return array;
    }
}

8，稀疏数组

面向对象

1，对象

2，方法

方法调用

静态方法：static关键字

非静态方法：实例化

值传递：

引用传递：

3，类与对象的创建

4，构造器

1，使用new 关键字，必须要有构造器（本质是在调用构造器）；

2，用来初始化值.

//一旦定义了有参构造，就必须先定义无参构造

快捷键：alt+insert 自动生成构造器

总结：

构造器：

1，和类名相同

2，没有返回值

作用：

1，new 本质是在调用构造方法

2，初始化对象的值

注意点：

1，定义有参构造之后，如果想使用无参构造，显示的定义一个午餐的构造

2，this. =

3,alt+insert

5，小结

6，封装

快捷键：alt+insert

作用：

1，提高程序安全性，保护数据

2，隐藏代码的实现细节

3，统一接口

4，系统可维护增加了

7，继承

super

super注意点：

1，super调用父类的构造方法，必须在构造方法的第一个

2，super必须只能出现在子类的方法或者构造方法中！

3，super和this不能同时调用构造方法

VS this：

代表的对象不同：

this：本身调用者这个对象

super：代表父类对象的应用

前提：

this：没有继承也可以使用

super：只能在继承条件才可以使用

构造方法：

this（）：本类的构造

super（）：父类的构造

方法重写

重写：需要有继承关系，子类重写父类的方法

1，方法名必须相同

2，参数列表必须相同

3，修饰符，范围可以扩大但不能缩小 public>protected>default>private

4，跑出的异常，范围可以被缩小不能被扩大 ClassNotFoundException–> Exception(大)

重写，子类的方法和父类必要一致，方法体不同！

为什么需要重写：

父类的功能，子类不一定需要，或者不一定满足

8，多态

注意：

1，多态是方法的多态，属性没有多态

2，父类和子类，有联系，类型转换异常，ClassCastException

3，存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1=new Son();

以下方法不能重写：

1.static 方法，属于类，他不属于实例

2.final 常量

3.private 方法

instance of

主要是看x是不是y的父类

类型转换

总结

1，父类引用指向子类的对象

2，把子类转换为父类，向上转型

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

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

9，static关键字

10，抽象类

特点：

1，不能new这个抽象类，只能靠子类去实现它，约束

2，抽象类中可以写普通的方法

3，抽象方法必须在抽类中

抽象的抽象：约束

11，接口

12，内部类

1，成员内部类

2，静态内部类

3，局部内部类

4，匿名内部类

异常

1，error 和exception

2，异常处理

快捷键：ctrl +alt+t

3，自义定异常

注：本笔记于b站up主“遇见狂神说”https://www.bilibili.com/video/BV12J41137hu
处学习记录，仅供学习与参考

键.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE-Java基础知识点笔记

注：本笔记于b站up主“遇见狂神说”https://www.bilibili.com/video/BV12J41137hu处学习记录，仅供学习与参考基础语法1，标识符和关键字关键字：标识符：2，数据类型强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后使用弱类型语言：js，vb等字节：3，数据类型拓展public class demo01 { public static void main(String[] args) { //整数扩展
复制链接

扫一扫

专栏目录