Java精简版笔记（篇1）持续更新

##

Java重要特点

Java语言是面向对象的oop

Java语言是健壮的

Java语言是跨平台性的

Java语言是解释型的

转义字符

\t 制表位 实现对齐功能

\n换行符

\r一个回车

变量

+号的使用

当左右两边都是数值型时 做加法运算

当左右两边有一方为字符串时 做拼接运算

数据类型

基本数据类型

数值型： 整数类型（存放整数）byte[1],short[2],int[4],long[8]

浮点（小数）类型 float[4].double[8]

字符型： char[2] 存放单个字符

布尔型: boolean[1] 存放true,false

 public class Text {   //这是布尔型的例子
     public static void main(String[] args) {
         boolean OK = true;     //定义一个布尔变量
         if (OK == true) {       //T赋值给OK（布尔值）
             System.out.println("通过");
         } else {
             System.out.println("未通过");
         }
 ​
     }
 }

引用数据类型

类（class）

接口（interface）

数组 [ ]

基本数据类型转换

数据类型按精度（容量）大小排序为

char => int => long => float => double

byte => short => int => long => float => double

转换细节

自动转换：

1、有多种类型的数据混合运算 系统首先将所有数据转换成容量最大的那种数据类型 然后计算

2、当把精度大的数据类型赋值给精度小的时 就会报错 反之会进行自动类型转换

3、（byte，short）和char之间不自动转换

4、byte、shot、char可计算

5、布尔值不参与转换

6、自动提升 即表达式结果的类型自动提升为 操作数中最大的类型

强制转换：

将容量大的数据类型转换为容量小的数据类型 使用时加上强制转换符（）

 public static void main(String[] args) {
     int i = (int) 1.9;
     System.out.println(i);
     int j = 100;
     byte b1 = (byte) j;
     System.out.println(b1);
 ​
 }

基本数据类型转String类型 将基本类型值+“ ”即可

 public static void main(String[] args) {
     int n1 = 100;
     String str1 = n1 + "";
     String str2 = n1 + "";
     System.out.println(str1 + "" + str2);
 }

String类型转换基本数据类型 通过本类型的包装类调用

 public static void main(String[] args) {
     Integer.parseInt("123");
     Double.parseDouble("123.4");
     Boolean.parseBoolean("true");
 }

运算符

算术运算符

 

 public static void main(String[] args) {
     System.out.println(10 / 4);     //2
     System.out.println(10.0 / 4);   //2.5
     double d = 10 / 4;
     System.out.println(d);          //2.0
     System.out.println(10 % 3);     //1
     System.out.println(-10 % 3);    //-1
     System.out.println(-10 % -3);   //-1
 }

++的使用

 public static void main(String[] args) {
     int i = 10;
     i++;  //自增  等价于 i = i + 1  =》i = 11
     ++i;  //自增  等价于 i = i + 1  =》i = 12
     System.out.println("i=" + i);  //12
     /*
     作为表达式使用
     前++ ++i先自增后赋值
     后++ i++先赋值后自增
      */
     int j = 9;
     int k = ++j; //j=j+1 j为10后赋值k为10
     int l = j++; //j为10先赋值l为10 后j=j+1 j=11
     System.out.println("k=" + k + "j=" + j + "l=" + l);
 }

关系运算符（比较运算符）

关系运算符的结果都是boolean型

 

逻辑运算符

用于连接多个条件（多个关系表达式） 最终结果为boolean

短路与 && 如果第一个条件为F 则第二个不判断 最终结果为F

短路或|| 不管第一个是否为F 第二个都会判断

取反！ 如果条件本身成立 则结果为F 否则为T

逻辑与& 如果第一个条件为T 则第二个不判断 最终结果为T

逻辑或| 不管第一个条件为T 第二个条件都要判断

逻辑异或^ 当a和b不同的时候 结果为T 否则为F

 

赋值运算符

将某个运算后的值 赋给指定的变量

+= -= *= /= %=

a += b 等价于a = a + b

a -= b 等价于a = a - b

三元运算符

条件表达式？表达式1：表达式2 （如果条件表达式为true 运算后结果是表达式1 ；如果表达式为false 运算后结果是表达式2）

运算符优先级

 

关键字

被Java语言赋予特殊含义 用作专门用途的字符串 （关键字中所有字母都为小写）

键盘输入

 public static void main(String[] args) {
     //创建Scanner对象 
     Scanner scanner = new Scanner(System.in);  
     System.out.println("请输入姓名");
     //接收用户输入
     String next = scanner.next();
     System.out.println("请输入年龄");
     String next1 = scanner.next();
     System.out.println(next +""+next1);
 }

控制结构

分支控制

单分支

当条件表达式为T时 执行{}的代码；如果为F 则不执行

 if(条件表达式){
     
     }

双分支

当表达式成立 则执行代码块1；否则执行代码块2

 if(条件表达式){
     执行代码块1;
     }
 else{
     执行代码块2;
     }

多分支

当表达式1成立时 则执行代码块1；

当表达式1不成立时 采取判断表达式2是否成立；

如果表达式2成立 就执行代码块2；

….

当所有表达式都不成立 则执行else的代码块

 if(条件表达式1){
     执行代码块1;
     }
 else if(条件表达式2){
     执行代码块2;
     }
 ....
     else{
         代码块n;
     }

嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构

 if(){
     if(){
         //if-else...
     }else{
         //if-else
     }
     }

switch分支结构

当表达式的值等于常量N 就会执行语句块N 若无匹配 则继续向下匹配

如果都未匹配上 执行default

 switch(表达式)
 ​
     {
         case 常量1:
             语句块1;
             break;
         case 常量2:
             语句块2;
             break;
             ...
         case 常量n:
             语句块n;
             break;
         default:
             default语句块;
             break;
     }

 public static void main(String[] args) {
     Scanner scanner = new Scanner(System.in);
     System.out.println("请输入一个字符a-c");
     char c = scanner.next().charAt(0);
     switch (c) {
         case 'a':
             System.out.println("今天周一");
             break;
         case 'b':
             System.out.println("今天周二");
             break;
         case 'c':
             System.out.println("今天周三");
             break;
         default:
             System.out.println("字符不正确");
     }
 }

for循环控制

让代码可以循环的执行

 for(循环变量初始化;循环条件;循环变量迭代){
     循环操作(可以多条语句);
   }

 public static void main(String[] args) {
     for (int i = 0; i < 10; i++) {
         System.out.println("加油 未来的架构师");
     }
 }

while循环控制

 循环变量初始化;
 while(循环条件){
     循环体(可以多条语句);
     循环变量迭代;
     }

 public static void main(String[] args) {
     //打印1-100之间能被3整除的数
     int i = 1;
     while (i <= 100){
         if(i % 3 == 0){
             System.out.println(i);
         }
         i++;
     }
 }

do..while循环控制

do while 是关键字

先执行 再判断 （一定会执行一次）

 循环变量初始化;
 do{
     循环体(语句);
     循环变量迭代;
    }while(循环条件);

 public static void main(String[] args) {//从1-100相加
     int i = 1;
     int sum = 0;
     do {
         sum += i;
         ++i;
     } while (i <= 100);
     System.out.println(sum);
 }

 //统计1-200之间能被5整除但不能被3整除的数
 //1、使用 do while 输出1-200
 //2、过滤能被5整除但不能被3整除的数
 //3、统计满足条件的个数count
 public static void main(String[] args) {
     int i = 1;
     int count = 0;
     do {
         if (i % 5 == 0 && i % 3 != 0) {
             System.out.println(i);
             count++;
         }
         i++;
     } while (i <= 200);
     System.out.println("count=" + count);
 }

 /*
 如果不好好学Java
 则一直鞭打 直到你好好学为止
  */
 public static void main(String[] args) {
     Scanner scanner = new Scanner(System.in);
     boolean choice = true;
     do{
         System.out.println("还好不好好学了？y/n");
         char c = scanner.next().charAt(0);
         if(c == 'y'){
             choice = false;
             System.out.println("加油 好好学Java！");
         }
     }while(choice);
 }

多重循环控制（重点！难点！）

1、将一个循环放在另一个循环体内 就形成了嵌套循环 （最好不要超过三层）

2、嵌套循环就是把内层循环当成外层循环的循环体 当只有内层循环的循环条件为F时 才会完全跳出内层循环 开始下一次循环

3、若外层循环为n，内层循环为m次，则实际内层循环需要执行m*n次

 /*
 打印空心金字塔
  */
 public static void main(String[] args) {
     for (int i = 1; i < 6; i++) {
         //在输出*之前 还有输出 对应空格=总层数-当前层
         for (int k = 1; k < 6 - i; k++) {
             System.out.print(" ");
         }
         //打印每层的*数
         for (int j = 1; j <= 2 * i - 1; j++) {  
             //当前行的位置是*时 最后一个位置也是*时 最后一层全为*时
             if (j == 1 || j == 2 * i - 1 || i == 5) {
                 System.out.print("*");
             } else { //空心部分输出空格
                 System.out.print(" ");
             }
         }
         //每打印完一层*后 换行
         System.out.println("");
     }
 }

跳转控制语句

当某个条件满足时 终止循环 break；

 {
     ...
     break;
     ...
 }

当break语句中出现在多层嵌套的语句块中时 可以通过标签来种植哪一层语句块

 lable1:{    ...
 }
 lable2:{    ...
 }
 lable3:{    ...
     break lable2;
              ...
 }