Java入门学习周记week01

Posted 2020-10-02

0.我为什么要写周记

作为一名Java初学者，我深知总结复习的重要性。我认为学习就是一个积累的过程。
所以我决定在这里记录下我每周学习的内容和一些总结，为以后的自己提供一些参考。

1.Java语言跨平台原理

平台：指的是操作系统(Windows，Linux，Mac) 

跨平台：Java程序可以在任意操作系统上运行
一次编写到处运行即java的.class程序可以在不同操作系统上均可以运行。
(java的.class文件相当于Windows中的.exe文件，是可执行的程序)

原理：实现跨平台需要依赖Java的虚拟机 JVM （Java Virtual Machine）

 

2.JDK与JRE

JDK : JRE+开发工具
JRE : JVM+核心类库
使用JDK开发完成的Java程序，交给JRE运行。（JDK中包含JRE）
安装网址 : http://www.oracle.com
注意事项 : 安装路径不要有中文或者特殊符号如空格等。开发工具最好安装目录统一。

 

3.在Eclipse编写HelloWorld

1 public class HelloWorld{
2     public static void main{
3     System.out.println("HelloWorld");
4   }
5 }

 

 

4.常量

 

    在程序执行的过程中，其值不可以发生改变的量。

字符串常量   用双引号括起来的内容(“HelloWorld”)
整数常量     所有整数(12,-23)
小数常量     所有小数(12.34)
字符常量     用单引号括起来的内容(‘a‘,‘A‘,‘0‘)
布尔常量     较为特有，只有true和false
空常量       null

5.变量

在程序执行的过程中，在某个范围内其值可以发生改变的量。

从本质上讲，变量是内存中储存数据的区域，你能用它来存数据和取数据,还可以改变这个数据。

格式:数据类型 变量名 = 初始化值;

 

八种	字节数	数据表示范围
byte	1	-128~127
short	2	-32768～32767
int	4	-2147483648～2147483647
long	8	-263～263-1
float	4	-3.403E38～3.403E38
double	8	-1.798E308～1.798E308
char	2	表示一个字符，如(‘a’，’A’，’0’，’家’)
boolean	1	只有两个值true与false

 

6.类型转换

默认转换 : 范围小的数据类型直接转换成范围大的数据类型转换规则

byte,short,char—int—long—float—double

注意事项 : byte,short,char相互之间不转换，他们参与运算首先转换为int类型

格式 : 范围大的数据类型 变量 = 范围小的数据类型值；

 1 public class DemoTypeCast {
 2     public static void main(String[] args) {
 3         //直接输出了运算的结果
 4         System.out.println(3 + 4);
 5 
 6         //定义两个int类型的变量
 7         int a = 3;
 8         int b = 4;
 9         int c = a + b;
10         System.out.println(c);
11 
12         //定义一个byte类型,定义一个int类型
13         byte bb = 2;
14         int cc = 5;
15         System.out.println(bb + cc);
16 
17         //用变量接收，这个变量应该有类型
18         //byte dd = bb + cc;//可能损失精度
19         //byte,short,char类型在参与运算的时候会把自己提升为int类型
20         int dd = bb + cc;
21         System.out.println(dd);
22     }
23 }

 

7.运算符

运算符概述

对常量和变量进行操作的符号称为运算符。

表达式概述

用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。    
不同运算符连接的式子体现的是不同类型的表达式。

常用的运算符

算术运算符 : + , - , * , / , %

赋值运算符 : 基础 : = 拓展: += , -= , *= , /= , %=

关系运算符 : == , != , > , < , >= , <=

逻辑运算符 : & , | , ! , ^ 

三元运算符 : (关系表达式) ? 表达式1 : 表达式2;
            (如果条件为true,运算后的结果是表达式1;)
            (如果条件为false,运算后的结果是表达式2;)

 

8.键盘录入Scanner类

导包(位置放到class定义的上面)
import java.util.Scanner;

创建对象
Scanner sc = new Scanner(System.in);

调用方法接收数据
int x = sc.nextInt();

 1 public class DemoScanner {
 2     public static void main(String[] args) {
 3         //创建键盘录入数据的对象
 4         Scanner sc = new Scanner(System.in);
 5 
 6         //接收数据
 7         System.out.println("请录入一个整数：");
 8         int i = sc.nextInt();
 9 
10         //输出数据
11         System.out.println("i:"+i);
12     }
13 }

 

9.流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说程序的流程对运行结果有直接的影响。 
所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

流控语句分为三个类

9.1 顺序结构

是程序中最简单最基本的流程控制，没有特定的语法结构， 
按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

9.2 选择结构

选择结构也被称为分支结构。

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

选择就结构有两种，if语句,switch语句。

 1 //if语句的三种格式
 2 if(){};
 3 if(){}else{};
 4 if(){}elseif(){}...else{};
 5 //switch语句
 6 switch(表达式){
 7 case 目标值1:
 8 语句体1;
 9 break;
10 case 目标值2:
11 语句体2;
12 break;
13 case 目标值3:
14 语句体3;
15 break;
16 .
17 .
18 .
19 default:
20 语句体n+1;
21 }

 

9.3 循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，
当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false， 
从而结束循环，否则循环将一直执行下去，形成死循环。
三种循环结构 1. for 2.while 3. do while

1 for(初始表达式;布尔表达式;步进表达式){
2     循环体;
3 }
4 //for循环中定义的变量一旦循环结束将不能使用
5 //for循环通常使用在次数确定的情况下

初始化表达式;
while(布尔表达式;){
    循环体;
    步进表达式;
}
//while循环通常使用在次数不确定的情况下

初始化表达式
do{
    循环体
    步进表达式
}while(布尔表达式);  
//do while 会先执行一次循环体，不论是否达成循环条件

 

 

10.跳转控制语句

我想让循环在某一步的时候结束或者跳过某些数据不要这些数据，现在就做不了这件事情。 
为了弥补这个缺陷，Java就提供了break，continue来实现控制语句的中断和跳转。

break 中断

break的使用场景： 

在选择结构switch语句中

在循环语句中

离开使用场景的存在是没有意义的

break的作用：

跳出单层循环

continue 继续

continue的使用场景：

在循环语句中

离开使用场景的存在是没有意义的

continue的作用：

单层循环对比break，然后总结两个的区别

break  结束当前循环

continue  结束本次循环,继续下一次循环

 

11.随机数Random

概述
用于产生一个随机数
使用步骤(和Scanner类似)

导包
import java.util.Random;
创建对象
Random r = new Random();
获取随机数
int number = r.nextInt(10);

产生的数据在0到10之间，包括0，不包括10。
括号里面的10是可以变化的，如果是100，就是0-100之间的数据。

也可以产生一个随机对象。

1 String s1 = r.next();
2 double s2 = r.nextdouble();
3 byte s3 = r.nextbyte();
4 .
5 .
6 .

 

12.数组

数组是存储同一种数据类型多个元素的容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];

数组的初始化分为两种

1.动态初始化

格式：数据类型[] 数组名 = new 数据类型[数组长度];
例：int[] arr = new int[3];

2.静态初始化

数据类型[] 数组名 = new 数据类型[]{元素值1,元素值2,…};
例：int[] arr = new int[]{1,2,3};

数组操作的两个常见小问题

数组索引越界异常ArrayIndexOfBoundsException
访问到了数组中的不存在的索引时发生。

空指针异常NullPointerException
数组引用没有指向对象，却在操作对象中的元素时。

13.二维数组

二维数组定义格式
数据类型[][] 数组名;（推荐）
数据类型 数组名[][]; 
数据类型[] 数组名[]; 

初始化方式
数据类型[][] 变量名 = new 数据类型[m][n];
m:二维数组的长度(二维数组中一维数组的个数)
n:二维数组中一维数组的长度

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

 1 //二维数组的遍历
 2 public class DemoArrayArrayTest {
 3     public static void main(String[] args) {
 4         // 定义二维数组
 5         int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
 6         for(int y=0; y<arr.length; y++) {
 7             for (int x = 0; x < arr[y].length; x++) {
 8                 System.out.print(arr[y][x] + "  ");
 9             }
10             System.out.println();//换行
11         }
12     }
13 }

 

14.方法

方法就是完成特定功能的代码块
在很多语言里面都有函数的定义
函数在Java中被称为方法

格式

修饰符 返回值类型  方法名(参数类型 参数名1，参数类型 参数名2…) {
方法体;
return 返回值;
}

格式解释

修饰符目前记住 public static
返回值类型用于限定返回值的数据类型
方法名一个名字，为了方便我们调用方法
参数类型用于接收调用方法时传入的数据的类型
参数名用于接收调用方法时传入的数据的变量
方法体完成功能的代码

return 结束方法，把返回值带给调用者
写一个方法首先有两点需要明确
返回值类型明确功能结果的数据类型
参数列表明确有几个参数，以及参数的类型

注意事项:方法定义完成之后,没有调用没有意义,不调用不执行。

 1 publicclass DemoMethod {    
 2     /*
 3      * 写一个方法，用于求和。
 4      * 两个明确：返回值类型int参数列表int a,int b
 5      */
 6     public static int sum(inta,intb){
 7         /*int c = a + b;
 8         return c;*/
 9         returna + b;
10     }
11 }

 

方法重载

方法重载概述

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

方法重载特点

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

public class Demo02Method {
    public staticvoid main(String[] args) {
        int a = 10;
        int b = 20;

        // 求和
        int result = sum(a, b);
        System.out.println("result:" + result);

        int c = 30;
        // 求和
        result = sum(a,b,c);
        System.out.println("result:"+result);
    }

    //两个float类型的数据求和
    public static float sum(float a,float b) {
        return a + b;
    }

    // 三个整数的求和
    public static int sum(inta,intb,intc) {
        return a + b + c;
    }

    // 两个整数的求和
    public static int sum(int a, int b) {
        return a + b;
    }
}

方法参数传递问题

参数传递概述
可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数， 
这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。

这种传递方式，我们称为参数传递。
在这里，定义方法时，参数列表中的变量，我们称为形式参数
调用方法时，传入给方法的数值，我们称为实际参数

参数是基本类型及图解
形式参数的改变不影响实际参数。

15.练习

1. 一年有四季;3,4,5春季;6,7,8夏季;9,10,11秋季;12,1,2冬季

用if语句实现

 1 public class Demo01Test {
 2     public static void main(String[] args) {
 3         // 键盘录入一个月份,用Scanner实现
 4         Scanner sc = new Scanner(System.in);
 5         // 接收数据
 6         System.out.println("请输入一个月份(1-12)：");
 7         int month = sc.nextInt();
 8                 if(month==1 || month==2 || month==12) {
 9             System.out.println("冬季");
10         }else if(month==3 || month==4 || month==5) {
11             System.out.println("春季");
12         }else if(month==6 || month==7|| month==8) {
13             System.out.println("夏季");
14         }else if(month==9 || month==10 || month==11) {
15             System.out.println("秋季");
16         }else {
17             System.out.println("你输入的月份有误");
18         }
19     }
20 }

用switch语句实现（case穿透）

 1 public class Demo02Test {
 2     public static void main(String[] args) {
 3         // 键盘录入一个月份,用Scanner实现
 4         Scanner sc = new Scanner(System.in);
 5         // 接收数据
 6         System.out.println("请输入月份(1-12)：");
 7         int month = sc.nextInt();
 8         //通过case穿透现象改进代码
 9         switch(month) {
10             case 1:
11             case 2:
12             case 12:
13                 System.out.println("冬季");
14                 break;
15             case 3:
16             case 4:
17             case 5:
18                 System.out.println("春季");
19                 break;
20             case 6:
21             case 7:
22             case 8:
23                 System.out.println("夏季");
24                 break;
25             case 9:
26             case 10:
27             case 11:
28                 System.out.println("秋季");
29                 break;
30             default:
31                     System.out.println("你输入的月份有误");
32                     break;
33         }
34     }
35 }

2.数组元素反转

 1 public class DemoTest {
 2     public static void main(String[] args) {
 3         // 定义一个长度为5的数组
 4         int[] arr = new int[5];
 5 
 6         // 通过键盘录入数据给数组中的元素赋值
 7         Scanner sc = new Scanner(System.in);
 8         for (int x = 0; x < arr.length; x++) {
 9             System.out.println("请给出第" + (x + 1) + "个元素");
10             arr[x] = sc.nextInt();
11         }
12 
13         System.out.println("反转前的数组元素：");
14         printArray(arr);
15 
16         // 定义方法将arr数组中的内容反转
17         reverse(arr);
18 
19         System.out.println("反转后的数组元素：");
20         //定义方法遍历数组
21         printArray(arr);
22     }
23 
24     //遍历数组
25     public static void printArray(int[] arr) {
26         System.out.print("[");
27         for(int x=0;x<arr.length; x++){
28             if(x == arr.length-1) {
29                 System.out.println(arr[x]+"]");
30             }else {
31                 System.out.print(arr[x]+", ");
32             }
33         }
34     }
35 
36     /*
37      * 两个明确： 返回值类型：void 参数列表：int[] arr
38      */
39     public static void reverse(int[] arr) {
40         /*
41         利用for循环遍历数组
42             初始化表达式定义两个指针,记录第一个元素和最后一个元素:int min = 0,max = arr.length-1;
43             布尔表达式:min<max;
44             步进表达式:min++,max--;
45         */
46         for(int min=0,max=arr.length-1;min<=max;min++,max--) {
47             //利用第三方变量完成数组中的元素交换*
48             int temp = arr[min];
49             arr[min] = arr[max];
50             arr[max] = temp;
51         }
52     }
53 }

3.数组作为返回值 
例：将五个参数中 平均值与和 存储到数组中并返回 
例如有五个int类型数据 4,23,221,2,111

 1  public class Test2 {
 2    public static void main(String[] args) {
 3 
 4       int[] arr =  getArr(4,23,221,2,111);
 5    }
 6   /*
 7    * 返回值类型是一个数组类型  说明返回值就是一个数组
 8    * 将五个参数中 平均值与和 存储到数组中并返回  
 9    *        第一个元素是平均值  第二个元素是和
10    */
11    public static int[] getArr(int a,int b,int c,int d,int e){
12       //求和 
13       int sum = a+b+c+d+e;
14       //求平均值
15       int avg = sum/5;
16       //将和与平均值存储到数组中
17       //创建一个数组  存储平均值与和 长度为2
18       int[] arr = new int[2];
19       arr[0] = avg;
20       arr[1] = sum;
21 
22       return arr;//返回的数组  
23    }
24 }