java学习笔记（1）

java基础语法

关键字

关键字：被Java语言赋予特定含义的单词，组成关键字的字母全部小写。

标识符

是给类,接口,方法,变量等起名字时使用的字符序列

由英文大小写字母，数字字符，$和_组成。

注意：不能以数字开头，且不能是java中的关键字，区分大小写。

命名规则

命名的作用是见名知意，编写类或变量时要说明其中作用或者保存的数据是什么。

不能使用中文来定义。

包：单词小写，多个单词时，使用.隔开。

类：单词的首字母大写，不同单词之间可以直接连接。

public class Dog{
    
}

"

"方法，变量：第一个单词是小写，后面所有单词的首字母大写并且可以直接连接。

// run方法
public void run(){ 
    
} 
public void exampleMethod() {
    int localVar = 10; // 局部变量
    // ...
}

常量：不会发生改变的量，所有单词大写，单词之间用_分割

String SUNDAY = "SUNDAY"

注释

用于说明当前代码要做的任务，编写代码要先写注释。注释的作用是解释代码逻辑，以及一些特殊含义的数据。

注释的种类：

单行注释： 快捷键 ctrl+/

// 这是一行注释

多行注释：快捷键 ctrl + shift + /

/*
这是多行注释
*/

文档注释 快捷键 输入/** + enter

/**
 * 这是文档注释
 */

常量

在程序执行中值不会发生改变。

字面值常量：

• 字符串常量

由多个字符组成，使用""括起来

String str ="哈哈";
    // 注意 只能使用""表示，不能使用''

• 整数常量

所有整数

int i = 1;

• 小数常量

double j  = 12.3;

• 字符常量

由单个字符组成，使用’'括起来

 char ch = '1'; 

• 布尔常量

只有true/false 值为关键字

 boolean bool1 = true;
 boolean bool2 = false;

• 空常量

null 为一个关键字，只能用于引用类型。

 String strNull = null;

原码，补码，反码

原码就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。

反码正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

补码正数的补码与其原码相同；负数的补码是在其反码的末位加1。

所有数据的运算都是采用补码进行的。

变量

类似数学中的x

由于java是一门静态类型语言，定义变量时必须指定类型，切不可改变。

Java中的变量类型

 1.基本数据类型(8种)
  byte short int long float double boolean char (Java中的关键字，都是小写)
     
     整数类型：
byte short int long
   byte 1字节  -128~127
   short 2字节 -2^15~2^15-1
   int 4 字节
   long 8 字节  定义时要加上l
   注意：对于Java在整型数据定义时，默认数据为int类型。
     
     小数类型
     float double
   float 4 字节  => 在定义数据时，需要在数值后添加 f/F标记
   double 8 字节
   注意：当定义小数数据时，默认类型为 double 类型
     
       布尔值
   boolean
   注意：值只能存在 true / false 有严格的大小写区分
     
       字符
   char  2字节

2.引用数据类型（面向对象）=> 其类型除了数组基本都可以使用首字母大写形式表示类型
    1.类： 字符串是属于类中的一种，类是由class修饰的一种类型
    2.接口：是一种特殊的类，只定义具体的规范，不能直接通过其对象进行操作
    3.数组：是一种数据集合 其定义的方式为  类型[] 表示一个集合中可以包含多个该类型的数据

变量定义格式

数据类型 变量名 = 初始化值;
数据类型 变量名 = new 类型对象

注意：变量定义在哪一级大括号中，哪个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名变量。

没有初始化值不能直接使用，每个基本数据类型都有其存储数据的规范：包括值类型和长度。一行一般只定义一个变量。

数据类型转换：

 /*隐式转换：
从低精度的类型转高精度类型 可以实现自动赋值转换，但是高精度向低精度转换会报错  会造成精度丢失的问题。
 2.显示转换（强制类型转换）
 格式： to类型 变量名 = (to类型)其他类型值
 注意：并不是所有的类型都可以使用强制类型转换 基本数类型之间可以进行转换 但是跨大类型和Bool不行
 */
  short toShort = (short) toInt;//int 转 short

数据类型之间进行数据计算：

两个变量计算，默认提升到int类型；

两个数值相加，内存中保存的是结果，之后再将结果赋予给想要的类型

字符串相加结果为字符串拼接，字符相加计算，结果为int类型

运算符

算术运算符

+ - * / %
//自增自减
    1.每次计算时，都会在当前变量中加1或减去1
    2.变量++ 表示先赋值后加1  ++变量 表示先加1后赋值
    想得到结果带有小数 => 当除数或被除数中存在有小数，那么得到的结果也包含有小数
       System.out.println(10 / 3.0);

赋值运算符

  = , +=, -=, *=, /=, %=
 注意：
  对数据进行计算后不修改其数据类型 可以使用赋值运算符
  对于多个变量的赋值是从右向左进行

关系运算符

== , ！=, >, <,<=,>=
 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
注2：比较运算符“==”不能误写成“=” 。

逻辑运算符

 &(与) |（或） ！（非） ^(异或)  &&（短路与） ||（短路或）
  逻辑：
  1.&(与) 当前后两个结果都为true 结果返回 true 否则false
  2.|（或） 当前后两个结果有一个为true 结果返回 true 否则false
  3.！（非） 当前结果进行取反
  4.^(异或) 当前后两个结果不同为true 否则返回false
  短路：
     ||，&&
   当左边的条件为true时，可以不用计算右边的表达式 直接返回true
   当左边的条件为false时，必须计算右边的表达式

位运算

位运算符：
<< 左移  相当于对当前值乘以 2^N次方
>> 右移动 相当于对当前值除以 2^N次方
>>> 无符号右移
& 与  | 或  &：同时为1才是1 |：有一个为1就是1
^ 异或
~ 反码

三目运算符

作用: 用于做逻辑判断，当结果为ture返回一个值，false返回另外一个值 和if语句相类似
格式：(判断条件?结果为true的返回值:结果为false的返回值)  判断条件要求返回ture或者false
    
    System.out.println(3 > 4 ? "3是大于4的" : "3是小于4的");

键盘录入

import java.util.Scanner;//第三方包导入
 Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();//调用对象的方法 nextint等等。获取一个整形数据或者其他类型的数据。

控制语句

1.顺序结构

就是程序中最简单最基本的流程控制，依次运行。

2.选择结构

代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

if语句：

if(判断语句) {
判断条件为true的执行语句
 }
if(判断语句) {
判断条件为true的执行语句
}else{
判断条件为false的执行语句
}
if(判断语句1) {
判断条件1为true的执行语句
}else if(判断语句2){
判断条件2为true的执行语句
}else{
判断条件为false的执行语句
}

java的if判断不可以返回数据，但是三目运算符可以返回值。

switch语句 选择判断语句

 switch(表达式) {
       case 值1：
       语句体1;
       break;
       case 值2：
       语句体2;
       break;
         …
       default：
       语句体n+1;
        break;
                }
运行逻辑：在执行时，通过表达式得到对应的值 再进入{}方法体
通过case语句进行匹配，如果case的值和 表达式得到对应的值 相同 那么就执行对应的 语句体。
当遇到有 break; 那么就退出
如果case语句没有匹配到值，那么会执行 default语句中的语句体
case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的。
default：可以在任意位置
如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。

3.循环结构

对于需要多次执行的代码，需要使用循环结构进行处理。

循环语句的组成：

初始化语句：只会被执行一次，完成一些初始化操作

判断条件语句：判断是否进入循环

循环体语句：需要多次做的事情

控制条件语句：通过用于控制循环条件中的变量，使得循环在合适的时候结束。

for循环

 for(初始化语句;判断条件语句;控制条件语句){
    循环体语句
}
初始化语句 -> 判断条件语句 -(true)-> 循环体语句 -> 控制条件语句
-(false)-> 退出循环
//不同for循环间可以定义相同变量名

while循环

 初始化语句;
while(判断语句){
循环体;
控制语句;
}
初始化语句 -> 判断语句  -(true)-> 循环体 ->  控制语句 ...
-(false)-> 退出循环

do…while

 初始化语句;
do{
循环体;
控制语句;
} while(判断语句);
 初始化语句 -> 循环体 -> 控制语句 -> 判断语句  -(true)-> 继续执行 循环体                                                     ---(false)-> 退出循环
     
 //与while不同的是do...while不管判断条件是否满足，都会执行一次循环体。

死循环

while(true){}
for(;;){}

4.跳转控制语句

break

在for，while循环中搭配使用，退出当前循环。

continue

在for，while循环中搭配使用,退出当次循环进入下一次循环.

双重循环控制语句下break和continue的使用

 break 默认每次执行都只能退出一个循环
 如果要退出多层循环,那么就需要对某一层循环进行标记 格式为:
 标记信息:for / while 同时 break后加上 标记信息

return

return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。应用在函数中，结束当前函数。

方法/函数

如果一段代码需要重复使用，重复出现，可以将其包装，形成一个方法，需要使用的时候，直接进行调用。

修饰符 返回值类型 方法名称(参数列表){
方法体(方法执行时的代码)
return 值; 如果有返回值的情况下
}
修饰符: 用于修饰当前方法的访问权限,以及方法的类型 public static/private
    
返回值类型:限定返回值的数据类型 基本数据类型 / 引用类型  如果没有返回值此时需要使用 void 关键字表示。
    
参数列表: 可以给定多个参数  格式: 参数类型 参数名
    1.形参  在参数列表中定义的 定义时,没有具体值 用于指代一个变量
    2.实参  在方法调用时,给方法的参数进行传入值称为实参
    
方法体:  具体的代码,可以直接调用其他方法
    
return: 如果方法没有返回值,可以不需要添加,return 返回值需要和返回值类型相匹配,每次执行返回一个值.    
public static int addFun(int a, short b) {
        return a + b;
    }
 int funRes = addFun(4, (short) 5);//实参
        System.out.println("funRes:" + funRes);
//a,b就是形参  如果给a,b具体的值  

1.方法调用,可以直接使用方法名(参数值)
2.方法在传参时,需要类型想对应
3.方法与方法是平级关系，不能嵌套定义，不能再方法内定义方法
4.方法调用的时候不用在传递数据类型
5.如果方法有明确的返回值，一定要有return带回一个值。没有返回值就是void类型的方法调用，只能单独调用。
    

方法重载

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

特点：与返回值类型无关，只看方法名和参数列表在调用时，虚拟机通过参数列表的不同来区分同名方法

public static void main(String[] args) {  
     System.out.println(add(3));//6
     System.out.println(add(2, 3));//5
}
public static int add(int a){
        return a+a;
    }

    public static int add(int a,int b){
        return a+b;
    }

方法递归

自己调用自己。

需要停止标志，否则会发生栈内存溢出错误java.lang.StackOverflowError。

public class text {
    public static void main(String[] args) {
        System.out.println(reloadFun(5)); // 120
    }
    public static int reloadFun(int n){
        // 当n不等于1时调用自身,等于1时返回结果1
        if (n == 1){
            return 1; //停止标志
        }else {
            return n * reloadFun(n-1);
        }
    }
}// 阶乘

数组

存储多个变量（元素）的容器，这些变量的数据类型相同，既可以存储基本数据类型，也可以存储引用数据类型，引用类型为空时可以用null表示。

初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

 格式1：数据类型[] 数组名;
 数据类型[] 数组名 = new 数据类型[长度]  -> 动态初始化
 数据类型[] 数组名 = new 数据类型[]{元素,元素,元素,...} -> 静态初始化
 数据类型[] 数组名 = {元素,元素,元素,...} -> 静态初始化
          String[] heroName = new String[3];
          heroName[0]="xx"
              ...
          String[] heroName = new String[]{x,xx,xxx};
          String[] heroName = {x,xx,xxx};
         
 格式2：数据类型 数组名[]
 数据类型 数组名[] = new 数据类型[长度]  -> 动态初始化
 数据类型 数组名[] = new 数据类型[]{元素,元素,元素,...} -> 静态初始化
 数据类型 数组名[] = {元素,元素,元素,...} -> 静态初始化
     

常见数组操作

//遍历
int num[] = {1,2,3,4,5,6}
 for (int elem : num) {
 System.out.println("获取到数据:" + elem);
}
//取最值
 int max = num[0];
 int min = num[0];
 for (int elem : num) {
      max = elem > max ? elem : max;
      min = elem < min ? elem : min;
}//循环比较数组中的值
System.out.println("max:"+max);
System.out.println("min:"+min);
/*数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
空指针异常
NullPointerException
操作实体中的元素时。找不到对应的内存地址
*/

打印数组

// getArrStr 方法
public class Demo13ArrayPrint {
    public static void main(String[] args) {
        int[] strArr = {1, 2, 3, 3, 2, 1, 4, 5, 6}
        System.out.println(getArrStr(strArr));
    }

    public static String getArrStr(int[] strArr) {
        String arrStr = "[";
        // 循环遍历strArr中的数据
        for (int i = 0; i < strArr.length; i++) {   
            if (i != strArr.length - 1) {
                arrStr += strArr[i] + ", ";// 不到最后一个就加逗号
            }else {
                arrStr += strArr[i]; // 最后一个数据不用加逗号
            }
        }
        arrStr += "]";
        return arrStr;
    }
}

二维数组

  格式1:
  数据类型[][] 变量名 = new 数据类型[m][n];
  m表示这个二维数组有多少个一维数组
  n表示每一个一维数组的元素个数
  String[][] allClassStu = new String[30][40];// 30个班级，每个班40个学生
// 给数据
  String[] oneClassStu = allClassStu[1];//取一个班级，再按照一维数组的方法给值。
   oneClassStu[0] = "xx";
  格式2:
  数据类型[][] 变量名 = new 数据类型[m][];
  String[][] allClassStu1 = new String[30][];// 30个班级，每个班学生数不同
//由于 new String[30][]; 定义时,对于第二个维度没有定义长度，直接给数据会报错java.lang.NullPointerException => 变量调用的内存地址为null 空
 allClassStu2[29] = new String[22];//重新创建一个字符串数组 其长度为 22 将其内存地址 赋予给 allClassStu2 变量的第29个下标的位置
// 再继续给数据
allClassStu2[29][0] = "xxx";
  格式3:
  数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
  数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
  String[][] allClassStu2 = new String[][]{{x,xx,xxx}...};//直接给数据
  String[][] allClassStu3 ={{x,xx,xxx}...};

// 遍历二维数组
//双重循环
int[][] allInt = {{1, 2, 4}, {2, 3, 4}, {2, 3, 4}};
 for (int i = 0; i < allInt.length; i++) {
            for (int index = 0; index < allInt[i].length; index++) {
                System.out.println(allInt[i][index]);
            }
        }