java

后端

发布日期: 2021-05-01

更新日期: 2022-08-17

文章字数: 2.1k

阅读时长: 8 分

阅读次数:

JAVA

基本数据类型

数据类型关键字包装类型内存占用取值范围

字节型 byte Byte 1个字节 -128~127
短整型 short Short 2个字节 -32768~32767
整型 int Integer 4个字节 -2^31~2^31-1
长整型 long(L) Long 8个字节 -2^63~2^63-1
单精度浮点数 float(F) Float 4个字节 38位
双精度浮点数 double(D) Double 8个字节 308位
字符型 char Character 2个字节 0~65535
布尔类型 boolean Boolean 1个字节 true,false

※数据范围和字节数不一定相关。如float范围比long大，但字节数小。

※浮点数是一个近似值：double s =4.0-3.6; //打印s为：0.3999999999

其本质是科学计数法,

第一位符号位,表示正负,0为负,1为正数
中间8(11)位即阶码,用以存贮指数位置的值
最后23(52)位即尾数,用以精确表示数字的值,各自精确小数点后6-7(15-16)

浮点数据类型比特位分配

※Infinity：无穷大，除以0可得，5.0/0

※NAN：not a number， 0.0/0

变量名

只能包含字母数字 _ $

杜绝

单个字母
中文（部分框架不允许）
中文拼音
不使用关键字

建议

小驼峰输入法（第一个首字母不大写） myScore， myJavaScore
大驼峰输入法（所有首字母都大写）
英文

变量计算

加减乘除

如果参与运算的类型不一样，则自动转化为相同类型
char\byte\short--int--long--float-doubleint*long=long*long    
byte、char、short 在参与运算时，一律为int计算结果会溢出
溢出不会报错，自动重新填(最大值加1为最小值) 

byte b1 = 5;
byte b2 = 6;
byte b3 = (byte)(b1+b2);

System.out.println(2+2);     //4
System.out.println(2+'2');   //52，2加上'2'的码50
System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50

变量取值最大数

int max = Integer.MAX_VALUE;
    System.out.println(max);

强转数据类型

int e = 129;
byte d = (byte) e;//注意溢出误差、精度丢失

两点原则

整数直接量可以直接赋值给byte,short,char，但不能超出范围
byte,short,char型数据参与运算时，系统会将其自动转换为int再运算

转义符（char类型）

特殊符号需要通过\来转义

char c1 = '女';  //字符女
char c2 = 'f';  //字符f
char c3 = '6';  //字符6
char c4 = '*';  //字符*
//char c5 = 女; //编译错误，字符型直接量必须放在单引号中
//char c6 = ''; //编译错误，单引号中必须有字符
//char c7 = '25'; //编译错误，只能有一个字符

char c8 = '\\'; //\为特殊符号，需要通过\来转义
System.out.println(c8); //\

交换变量（三个杯子原理）

int a = 5;
int b = 8;
int t = a;
a = b;
b = t;//首尾相连

语法

分支


  if语句                           switch语句
if(关系表达式){                 siwtch(表达式){
语句体;          
  } else if(关系表达式){             case 常量值1: 语句体1;break;
语句体;                        case 常量值2: 语句体2;break;  
  } else {                           …
语句体;                        default:语句体n;break;
}                               }

byte、short、int、char、String、枚举

在条件选择后以此为开始，向下贯穿。JAVA

循环

普通for循环：
    for(初始表达式;布尔表达式;步进表达式){
     循环体；
}

while循环：
    初始表达式;
  while(条件判断){
     循环体;
步进语句;}

do-while循环：初始表达式;
   do{
     循环体;
      步进语句;
}while(条件判断);

break：跳出循环———–可以用在switch和循环中
continue：跳过循环体中剩余语句而进入下一次循环——只能用在循环中

数组

复制

System.arraycopy(a,1,b,0,4);

int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0
//a:源数组
//1:源数组的起始下标
//b:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数
System.arraycopy(a,1,b,0,4); //灵活性好
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

int[] b = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1); //数组的扩容

int[] a = {10,20,30,40,50};
//a:源数组
//b:目标数组
//6:目标数组的长度
//----若目标数组的长度>源数组长度，则在末尾补默认值
//----若目标数组的长度<源数组长度，则将末尾的截掉
int[] b = Arrays.copyOf(a,6);
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

//数组的扩容
int[] a = {10,20,30,40,50};
//数组的扩容(创建了一个更大的新的数组，并将数据复制进去了)
a = Arrays.copyOf(a,a.length+1);
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
}

排序

Arrays.sort(arr);

int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
    arr[i] = (int)(Math.random()*100);
    System.out.println(arr[i]);
}
Arrays.sort(arr); //对arr进行升序排列
System.out.println("排序后:");
for(int i=0;i<arr.length;i++){  
    System.out.println(arr[i]);
}
System.out.println("倒序输出"); //只是倒着显示，但数组中数据没有改变
for(int i=arr.length-1;i>=0;i--){
    System.out.println(arr[i]);
}

数组异常

数组超过长度异常
空指针异常（NullPointerException）：栈上的变量为赋值null,指针被消除，与堆的联系中断

方法（函数）

定义五要素

返回值可有（特定数据类型 int 、boolean、数组等等）可无（void）
修饰词
方法名

见名字知意思
参数列表
- 有参传进去的为指针
参数里面的数值表示引用，调用引用数据类型的地址和基本数据类型的地址

基本数据类型的值不能改变（改变为另一个声明，使用需要return）

应用数据类型不能改变对象，可以改变对象的值，数组的值
方法体

具体实现

方法：函数、过程
- 封装一段特定的业务逻辑功能
- 尽可能独立，一个方法只干一件事
- 方法可以被反复调用多次
- 可以减少代码重复，有利于代码维护
- 何时用：假设有一个功能，在很多地方都得使用，就将功能封装到一个方法中
- 行参：声明方法变量时
  
  实参：调用方法时

方法的定义：

//无参无返回值
public static void say(){
    System.out.println("大家好，我叫WKJ，今年38岁了");
}

//有参无返回值
public static void sayHi(String name){ //形参
    System.out.println("大家好，我叫"+name+"，今年38岁了");
}

//有参无返回值
public static void sayHello(String name,int age){ //形参
    System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
}

//无参有返回值
public static double getNum(){
    //若方法有返回值，则在方法中必须出现return关键字
    //并且return后的数的类型必须与返回值类型匹配
    //return "abc"; //编译错误
    return 8.88; //1)结束方法的执行  2)返回结果给调用方
}

//有参有返回值
public static int plus(int num1,int num2){
    int num = num1+num2;
    return num; //返回的是num里面的那个数
    //return num1+num2; //返回的是num1与num2的和
}

//无参有返回值
public static int[] testArray(){
    int[] arr = new int[10];
    for(int i=0;i<arr.length;i++){
        arr[i] = (int)(Math.random()*100);
    }
    return arr;
}

方法的调用：

无返回值：方法名(有参传参);

public class MethodDemo {
    public static void main(String[] args) {
        say(); //调用say()方法

        //sayHi(); //编译错误，有参则必须传参
        //sayHi(250); //编译错误，参数类型必须匹配
        sayHi("zhangsan"); //String name="zhangsan"  //实参
        sayHi("lisi"); //String name="lisi"          //实参
        sayHi("wangwu"); //String name="wangwu"      //实参

        sayHello("zhangsan",25); //实参 String name="zhangsan",int age=25
        sayHello("lisi",24); //实参
    }
}

有返回值：数据类型变量 = 方法名(有参传参);

//方法的演示
public class MethodDemo {
    public static void main(String[] args) {
        double a = getNum(); //getNum()的值就是return后的那个数
        System.out.println(a); //8.88，模拟对返回值的后续操作

        int b = plus(5,6); //plus(5,6)的值就是return后的那个数
        System.out.println(b); //11，模拟对返回值的后续操作

        int m=5,n=6;
        int c = plus(m,n); //传递的是m和n里面的数
        System.out.println(c); //11，模拟对返回值的后续操作

        int[] d = testArray();
        System.out.println("长度为:"+d.length); //10，模拟对返回值的后续操作
        for(int i=0;i<d.length;i++){ //模拟对返回值的后续操作
            System.out.println(d[i]);
        }
    }
}

return：
- return 值; //1) 结束方法的执行 2) 返回结果给调用方
- return; //1) 结束方法的执行

hyy

https://hyflosaqer.github.io/2021/05/01/java-ji-chu-yu-fa/

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 hyy !

java

面向对象浅见

2021-05-13 后端

java

我的第一篇博客

2021-04-27 Hyy

java基础语法

JAVA

基本数据类型

变量名

变量计算

加减乘除

变量取值最大数

强转数据类型

两点原则

转义符（char类型）

交换变量（三个杯子原理）

语法

分支

循环

数组

复制

排序

数组异常

方法（函数）

定义五要素

具体实现

你的赏识是我前进的动力