1.java基础-CSDN博客

本文链接：https://blog.csdn.net/cycyong/article/details/129771305

记录一下狂神讲的Java基础笔记和自己的一些感悟！

1.标识符注意事项

所有标识符都应该以字母、美元($) 、下划线(_)开始
首字符之后可以是字母、美元符($) 、下划线(_)或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的,即区分大小写
可以使用中文命名，但是很low，也不建议使用拼音，更low
标识符起名字应该做到见名知意
下面是一些合法的表示符举例：

合法：age、$salary._value.1_value
非法：123abc、-salary、#abc

idea常用快捷键：
ctrl + D:复制当前行
ctrl + R:替换

2.数据类型

强类型语言:所有变量都必须先定义后才能使用
Java的数据类型分为两大类:基本类型和引用类型

在这里插入图片描述

2.1八大基本数据类型：

byte
short
int
long
float
double
char
boolean

注意：String不是基本数据类型,它是类

2.2 什么是字节

位(bit):是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
字节(byte):是计算机中数据处理的基本单位，习惯上用大写B来表示, 1B (byte,字节)= 8bit(位)
字符:是指计算机中使用的字母、数字、字和符号 1bit表示1位， 1Byte表示一个字节1B=8b。
1024B=1KB
1024KB=1MB 1024M=1GB.

2.3 整数拓展

二进制:0b
八进制:0
十进制:
十六进制:0x

 int i = 10;//默认十进制
 int i2 = 010;//八进制：0
 int i3 = 0x10;//十六进制：0x
 System.out.println(i);//10
 System.out.println(i2);//8
 System.out.println(i3);//16

2.4 浮点数拓展

面试题：银行业务字母怎么表示钱? BigDecimal(数学工具类)
float 有限﹑离散舍入误差大约接近但不等于
double是有问题的，最好避免使用浮点数进行比较

float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);//false
float d1 = 2332323232323232f;
float d2 = d1+1;
System.out.println(d1==d2);//true
//精度问题,最好完全避免使用浮点数进行比较

注意:最好完全避免使用浮点数进行比较

2.5 字符拓展

字符扩展：所有字符本质还是数字

char c1 = 'a';
char c2 = '中';
System.out.println(c1);//a
System.out.println((int)c1);//97
System.out.println(c2);//中
System.out.println((int)c2);//20013

2.6 布尔值扩展

boolean flag = true;
if(flag==true){} //新手
if(flag){}	//老手这样写 Less is More(代码要精简易读)

注意点：

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换为低容量的时候,使用强制类型转换
转换的时候可能存在内存溢出,或者精度问题!

byte、short、char->int->long->float->double(低->高)
强制转换:高->低
自动转换:低->高

2.7 用户交互Scanner

通过Scanner类的next()与nextLine()方法获取用户的字符串，读取前一般用hasNext()与hasNextLine()判断是否还有输入的数据。

public static void main(String[] args) {
    //创建一个扫描器对象
    Scanner scanner = new Scanner(System.in);

    System.out.println("使用next方式接收");
    //判断用户有没有输入字符串
    if(scanner.hasNext()){  //使用hasNextLie()会接收一行 "hello word"
        //使用next方式接收
        String str = scanner.next(); // 程序会等待用户输入完毕
        System.out.println("输入的内容为："+str);
        //input: hello word
        //输入的内容为：hello
    }
    //凡是属于IO流的类如果不关闭会一直占用资源
    scanner.close();
}

next():不能得到带有空格的字符串输入Hello world! 只能得到Hello
nextline():以Enter为结束符,输入回车之前所有字符,可以获得空白

3.变量与常量

变量:就是可以变化的量
Java是一种强类型语言,每个变量都必须声明其类型
java变量是程序中最基本的存储单源,其要素包括变量名、变量类型和作用域

3.1 变量的作用域

根据变量的作用域可分为下列三种变量：

类变量/static变量
实例变量
局部变量

public class Demo06 {
	static int allClicks = 0;//类变量
    String str = "Hello world";//实例变量
    public void method(){
    	int i = 0;//局部变量
    }
}

3.2 常量

关键词：final
常量名一般使用大写字符

final 常量名 = 值
final double PI = 3.14;
//修饰符不存在先后顺序
static final double PI = 3.14;

变量的命名规范：

所有变量、方法、类名:见名知意
类成员变量:首字母小写和驼峰原则:monthSalary
局部变量:首字母小写和驼峰原则
常量:大写字母和下划线:MAX_VALUE
类名:首字母大写和驼峰原则:Man、GoodMan
方法名:首字母小写和驼峰原则:run()、runRun()

4.运算符

算数运算符
	+ - * / % ++ --
赋值运算符
    = += -= *= /=
关系运算符
    > < >= <= == != instanceof
逻辑运算符
    && || !
位运算符
    & | ^ ~ >> << >>>
条件运算符
    ? :
Math类(工具类)
    2^3 = 8
    Math.pow(2,3) = 8

4.1位运算

A = 0011 1100
B = 0000 1101
A&B 0000 1100  //A B做与运算
A|B 0011 1101  //A B做或运算
A^B 0011 0001  //异或(相同得0,不同得1)
~B  1111 0010  //取反

5.包机制

一般利用公司域名倒置做包名

使用import导入包

com.kuang.operation
com.kuang.*(这个包下所有的类)

6.方法

用一段用来完成特定功能的代码片段

Java是值传递还是引用传递？答:值传递

6.1 方法的重载

方法重载的规则:

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

6.2 可变参数

可变参数实质是一个数组
可变参数必须放在参数列表的最后一个,否则会报错

package chapter03;

public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        demo03.test(1,2,3,42,123,341,2,1,32,123,41324,342,34,1);
    }
    public void test(int x,int... i){//可变参数放在参数列表的最后一个,否则报错
        int res = i[0];
        for(int j=1;j<i.length;j++){
            if(i[j]>res)
                res = i[j];
        }
        System.out.println(res);
    }
}

6.3 递归

自己调用自己,必须要有一个出口
java都是栈机制

package chapter03;

//学习递归思想:求出4的阶乘
public class Demo04 {
    public static void main(String[] args) {
        System.out.println(fun(4));
    }

    private static int fun(int num) {
        //出口
        if(num==1)
            return 1;
        else{
            return num*fun(num-1);
        }
    }
}

7. 数组

数组就是一组数
数组从0开始,比如创建10个单元,则为0~9,没有10,合法区间是[0,length-1]
数组对象本身在堆中,数组变量属于引用类型
Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException:是数组越界了

package chapter04;

public class Demo01 {
    public static void main(String[] args) {
        int[] nums;//1.声明数组,但是还没分配空间
        //int[] nums = new int[10];
        //声明和分配空间可以写在一起
        nums = new int[10];//2.可以存放10个int类型的数字

        //3.赋值
        for(int i=0;i<nums.length;i++){
            nums[i] = 1+i;
        }
        for(int i=0;i<nums.length;i++)
            System.out.println(nums[i]);
    }
}

7.1数组的三种初始化

静态初始化:
动态初始化:
默认初始化:基本为0

package chapter04;
public class Demo02 {
    public static void main(String[] args) {
        //静态初始化:创建 + 赋值
        int[] a = {1,2,3,4,5,6,7,8};
        System.out.println(a[0]);//1

        //动态初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);//10

        //默认初始化
        int[] c = new int[10];
        System.out.println(c[0]);//0
    }
}

7.2 数组的使用

普通的for循环
for-each循环
数组作为方法入参
数组作为返回值

package chapter04;
public class Demo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        print(arrays);
        print2(arrays);
        print(reverse(arrays));
    }
    // 1.for-i循环
    public static void print(int[] nums){
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
    //2.for-each循环
    public static void print2(int[] nums){
        for (int num: nums) {
            System.out.println(num);
        }
    }
    //3数组方法入参、返回
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转操作
        for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

7.3 二维数组

package chapter04;
public class Demo04 {
    public static void main(String[] args) {
        int [][] array = {{1,2},{3,4},{5,6}};
        printAarray(array[1]);
    }
    
    public static void printAarray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }
}

7.4 Arrays类

注意：Arrays.fill和数组一样也是左闭右开

package chapter04;
import java.util.Arrays;
public class Demo05 {
    public static void main(String[] args) {
        int[] a = {11,54,12,4,653,12341,7464,14,5598,2411};
        System.out.println(a);//[I@10f87f48
        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        //排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //数组填充(和数组一样左闭右开)
        Arrays.fill(a,2,4,88);
        System.out.println(Arrays.toString(a));
    }
}

7.5 冒泡排序

package chapter04;
public class Demo06 {
    public static void main(String[] args) {
        int[] a = {11,54,12,14,653,12341,7464,14,5598,2411};
        print(a);
        a = fun_sort(a);
        System.out.println("");
        print(a);
    }
    //冒泡排序
    public static int[] fun_sort(int[] a){
        for (int i=0;i<a.length-1-i;i++){
            for (int j=i;j<a.length;j++){
                if (a[i]>a[j]){
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
            }
        }
        return a;
    }
    //输出数组元素
    public static void print(int[] a){
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}