JAVA入门1

时间 2019-12-07

标签 java 入门栏目 Java 繁體版

原文原文链接

课程地址：https://www.imooc.com/learn/85html

1、初体验

1.1介绍

1.2开发环境：

下载地址：http://www.oracle.com/technetwork/java/javase/downloads/jdk9-downloads-3848520.htmljava

JAVA_HOME
C:\Program Files\Java\jdk-9.0.4

C:\Program Files\Java\jdk-9.0.4\bin

.;C:\Program Files\Java\jdk-9.0.4\lib

1.3编写java程序

（1）记事本开发：编程

public class HelloWorld{
	public static void main(String[] args){
		System.out.printIn("welcome to imooc!");
	}
}

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("welcome to imooc!");

    }
}

运行后多增长了个.class的文件数组

（2）Eclipse工具开发：安全

Eclipse下载地址：https://www.eclipse.org/downloads/oracle

1.4建立一个项目文件

（1）建立java项目dom

（2）建立程序包eclipse

（3）编写java源程序工具

（4）运行java程序spa

空白地方右击

1.5MyeElipse的使用

下载地址：http://www.my-eclipse.cn

自动建立包

1.6程序的移植

项目右击属性

导入：

2、变量和常量

2.1关键字,标识符，变量

Java 关键字是区分大小写的

public class HelloWorld{
    public static void main(String[] args) {
		String hobby = '慕课网';
		System.out.println(hobby);
	}
}

2.2语言类型：

Java 语言是一种强类型语言。通俗点说就是，在 Java 中存储的数据都是有类型的，并且必须在编译时就肯定其类型。 Java 中有两类数据类型：

在 Java 的领域里，基本数据类型变量存的是数据自己，而引用类型变量存的是保存数据的空间地址。说白了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应。

2.3使用规则

一、Java 中的变量须要先声明后使用

二、变量使用时，能够声明变量的同时进行初始化

，

也能够先声明后赋值

三、变量中每次只能赋一个值，但能够修改屡次

四、main 方法中定义的变量必须先赋值，而后才能输出

五、虽然语法中没有提示错误，但在实际开发中，变量名不建议使用中文，容易产生安全隐患，譬如后期跨平台操做时出现乱码等等

2.4Java中的自动类型转换

在 Java 程序中，不一样的基本数据类型的数据之间常常须要进行相互转换。例如：

，

代码中 int 型变量 score1 能够直接为 double 型变量 score2 完成赋值操做，运行结果为： 82.0

这种转换称为自动类型转换。

固然自动类型转换是须要知足特定的条件的：

1. 目标类型能与源类型兼容，如 double 型兼容 int 型，可是 char 型不能兼容 int 型

2. 目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，所以 double 类型的变量里直接能够存放 int 类型的数据，但反过来就不能够了

2.6Java中的强制类型转换

语法：( 数据类型 ) 数值

运行结果：

能够看到，经过强制类型转换将 75.8 赋值给 int 型变量后，结果为 75，数值上并未进行四舍五入，而是直接将小数位截断。

2.7Java常量的应用

所谓常量，咱们能够理解为是一种特殊的变量，它的值被设定后，在程序运行过程当中不容许改变。

语法：final 常量名 = 值;

程序中使用常量能够提升代码的可维护性。例如，在项目开发时，咱们须要指定用户的性别，此时能够定义一个常量 SEX，赋值为 "男"，在须要指定用户性别的地方直接调用此常量便可，避免了因为用户的不规范赋值致使程序出错的状况。

2.8如何在Java中使用注释

在编写程序时，常常须要添加一些注释，用以描述某段代码的做用。

通常来讲，对于一份规范的程序源代码而言，注释应该占到源代码的 1/3 以上。所以，注释是程序源代码的重要组成部分，必定要加以重视哦！

Java 中注释有三种类型：单行注释、多行注释、文档注释

运行结果： Hello Imooc!

看：被注释的代码块在程序运行时是不会被执行的~~

咱们能够经过 javadoc 命令从文档注释中提取内容，生成程序的 API 帮助文档。

打开首页，查看下生成的 API 文档

PS：使用文档注释时还可使用 javadoc 标记，生成更详细的文档信息：

@author 标明开发该类模块的做者

@version 标明该类模块的版本

@see 参考转向，也就是相关主题

@param 对方法中某参数的说明

@return 对方法返回值的说明

@exception 对方法可能抛出的异常进行说明

三.经常使用的运算符

3.1分类

Ø 算术运算符

Ø 赋值运算符

Ø 比较运算符

Ø 逻辑运算符

Ø 条件运算符

3.2算数运算符

其中，++ 和 -- 既能够出如今操做数的左边，也能够出如今右边，但结果是不一样滴

例1：

运行结果：

例2：

运行结果：

必定要注意哦！自增和自减运算符只能用于操做变量，不能直接用于操做数值或常量！例如 5++ 、 8-- 等写法都是错误滴！

3.3赋值运算符

赋值运算符是指为变量或常量指定数值的符号。如可使用 “=” 将右边的表达式结果赋给左边的操做数。

Java 支持的经常使用赋值运算符，以下表所示：

3.4比较运算符

比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较的结果是一个布尔值（ true 或 false ）。

Java 中经常使用的比较运算符以下表所示：

注意哦：

一、 > 、 < 、 >= 、 <= 只支持左右两边操做数是数值类型

二、 == 、 != 两边的操做数既能够是数值类型，也能够是引用类型

3.5逻辑运算符

逻辑运算符主要用于进行逻辑运算。Java 中经常使用的逻辑运算符以下表所示：

咱们能够从“投票选举”的角度理解逻辑运算符：

一、与：要求全部人都投票赞成，才能经过某议题

二、或：只要求一我的投票赞成就能够经过某议题

三、非：某人本来投票赞成，经过非运算符，可使其投票无效

四、异或：有且只能有一我的投票赞成，才能够经过某议题

当使用逻辑运算符时，咱们会遇到一种颇有趣的“短路”现象。

譬如：( one > two ) && ( one < three ) 中，若是能肯定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 啦。

同理，在( one > two ) || ( one < three ) 中，若是能肯定左边表达式的运行结果为 true , 则系统也一样会认为已经没有必要再进行右侧的 one < three 的执行啦！

3.6条件运算符

条件运算符（ ? : ）也称为 “三元运算符”。

语法形式：布尔表达式？表达式1 ：表达式2

运算过程：若是布尔表达式的值为 true ，则返回 表达式1 的值，不然返回 表达式2 的值

例如：

由于，表达式 8>5 的值为 true ，因此，返回： 8大于5

3.7运算符的优先级

所谓优先级，就是在表达式中的运算顺序。Java 中经常使用的运算符的优先级以下表所示：

级别为 1 的优先级最高，级别 11 的优先级最低。譬如，x = 7 + 3 * 2 获得的结果是 13 “先乘后加”嘛!

PS：你们不必去死记运算符的优先级顺序，实际开发中，通常会使用小括号辅助进行优先级管理。例如：

分析：小括号优先级最高，所以

一、执行 a + 18 ，结果为 30

二、执行( a + 18 ) % 4 取模，结果为 2

三、执行 a * ( ( a + 18 ) % 4 )，结果为 24

四.流程控制语句

4.1条件语句

（1）if

语法：

执行过程：

如：

注意哦：若是 if 条件成立时的执行语句只有一条，是能够省略大括号滴！但若是执行语句有多条，那么大括号就是不可或缺的喽~~

（2）if...else

语法：

执行过程：

如：

（3）多重 if

语法：

执行过程：

如：

（4）嵌套 if

语法：

执行过程：

例如：

运行结果为： 去室外游乐场游玩

（5）switch

语法：

执行过程：当 switch 后表达式的值和 case 语句后的值相同时，从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；若是没有匹配的 case 语句则执行 default 块的代码。

如：

不得不说的几点小秘密：

一、 switch 后面小括号中表达式的值必须是整型或字符型

二、 case 后面的值能够是常量数值，如一、2；也能够是一个常量表达式，如 2+2 ；但不能是变量或带有变量的表达式，如 a * 2

三、 case 匹配后，执行匹配块里的程序代码，若是没有碰见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束如

，

运行结果：

四、能够把功能相同的 case 语句合并起来，如

五、 default 块能够出如今任意位置，也能够省略

4.2循环语句

（1）while

语法：

执行过程：

< 1 >、判断 while 后面的条件是否成立( true / false )

< 2 >、当条件成立时，执行循环内的操做代码，而后重复执行< 1 >、< 2 >，直到循环条件不成立为止

特色：先判断，后执行

如：

（2）do...while

语法：

执行过程：

<1>、先执行一遍循环操做，而后判断循环条件是否成立

<2>、若是条件成立，继续执行< 1 > 、< 2 >，直到循环条件不成立为止

特色： 先执行，后判断

因而可知，do...while 语句保证循环至少被执行一次！

例如，依然输出 1000 遍“我爱慕课网”，使用 do...while 的实现代码为：

（3）for

语法：

执行过程：

<1>、执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次

<2>、进行循环条件的判断，若是条件为 true ，则执行循环体内代码；若是为 false ，则直接退出循环

<3>、执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断

<4>、依次从新执行< 2 >、< 3 >、< 4 >，直到退出循环

特色：相比 while 和 do...while 语句结构更加简洁易读

例如，输出 1000 遍“我爱慕课网”，使用 for 的实现代码为：

须要留心的几个小细节：

一、 for 关键字后面括号中的三个表达式必须用 “;” 隔开，三个表达式均可以省略，但 “;” 不能省略。

a. 省略“循环变量初始化”，能够在 for 语句以前由赋值语句进行变量初始化操做，如:

b. 省略“循环条件”，可能会形成循环将一直执行下去，也就是咱们常说的“死循环”现象，如:

在编程过程当中要避免“死循环”的出现，所以，对于上面的代码能够在循环体中使用 break 强制跳出循环（关于 break 的用法会在后面介绍）。

c. 省略“循环变量变化”，能够在循环体中进行循环变量的变化，如：

二、 for 循环变量初始化和循环变量变化部分，能够是使用 “,” 同时初始化或改变多个循环变量的值，如：

代码中，初始化变量部分同时对两个变量 i 和 j 赋初值，循环变量变化部分也同时对两个变量进行变化，运行结果：

三、循环条件部分可使用逻辑运算符组合的表达式，表示复杂判断条件，但必定注意运算的优先级，如：

代码中，必须同时知足变量 i 小于 10 ，而且 i 不等于 5 时才会进行循环，输出变量 i 的值。

（4）循环跳转语句break

例如，使用循环输出 1--10的数值，其中，若是数值大于 2 ，而且为 3 的倍数则中止输出。

实现代码：

运行结果：

（5）循环跳转continue

continue 的做用是跳过循环体中剩余的语句执行下一次循环。

例如，打印 1--10 之间全部的偶数，使用 continue 语句实现代码为：

运行结果：

（6）多重循环

以下所示：

例如：使用 * 打印长方形：

实现代码为：

执行流程：当 i = 1 时，外层循环条件成立，进入内层循环，开始打印第一行内容。此时， j 从 1 开始，循环 8 次，内层循环结束后换行，实现第一行 8 个 * 的输出。接下来返回外层循环 i 变为 2 ，准备打印下一行，依此类推，直到完成长方形的打印。

6、数组

数组能够理解为是一个巨大的“盒子”，里面能够按顺序存放多个类型相同的数据，好比能够定义 int 型的数组 scores 存储 4 名学生的成绩

数组中的元素均可以经过下标来访问，下标从 0 开始。例如，能够经过 scores[0] 获取数组中的第一个元素 76 ，scores[2] 就能够取到第三个元素 92 啦！

public class HelloWorld {
    public static void main(String[] args) {

		// 定义一个数组，保存五名学生的成绩
		int[] scores = { 78, 93, 97, 84, 63 };

		// 输出数组中的第二个成绩
		System.out.println("数组中的第2个成绩为：" +    scores[1]        );
	}
}

6.1使用 Java 中的数组:

四个步骤：

一、声明数组

语法： 数据类型[ ] 数组名；

或者 数据类型数组名[ ]；

其中，数组名能够是任意合法的变量名，如：

二、分配空间

简单地说，就是指定数组中最多可存储多少个元素

语法： 数组名 = new 数据类型 [ 数组长度 ];

其中，数组长度就是数组中能存放元素的个数，如：

话说，咱们也能够将上面的两个步骤合并，在声明数组的同时为它分配空间，如：

三、赋值

分配空间后就能够向数组中放数据了，数组中元素都是经过下标来访问的，例如向 scores 数组中存放学生成绩

四、处理数组中数据

咱们能够对赋值后的数组进行操做和处理，如获取并输出数组中元素的值

在 Java 中还提供了另一种直接建立数组的方式，它将声明数组、分配空间和赋值合并完成，如

它等价于：

答案:B

6.2循环操做 Java 中的数组：

实际开发中咱们常用循环控制数组成员的操做。如：

运行结果：

其中， 数组名.length 用于获取数组的长度

须要注意的“小毛病”：

一、 数组下标从 0 开始。所以 scores[3] ，表示数组中的第 4 个元素，而并不是第 3 个元素

二、数组下标的范围是 0 至数组长度-1 ，若是越界访问，就会报错。如：

运行时会报以下错误：

上面错误信息的意思是数组下标超过范围，即数组访问越界。在上面的代码中建立一个长度为 2 的数组，所以数组下标范围是 0 到 1 ，而程序中下标出现了 2 ，即 scores[2] ，超过了范围，形成数组访问越界。

6.3使用 Arrays 类操做 Java 中的数组:

Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操做数组，好比可直接实现数组的排序、搜索等（关于类和方法的相关内容在后面的章节中会详细讲解滴~~）。

Arrays 中经常使用的方法：

一、排序

语法： Arrays.sort(数组名);

可使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就能够完成对该数组的排序（按升序排列），如：

运行结果：

二、将数组转换为字符串

语法： Arrays.toString(数组名);

可使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素链接在一块儿，多个元素之间使用逗号和空格隔开，如：

运行结果为：

输出数组nums中的元素：[25，7，126，53，14，86]

6.4使用 foreach 操做数组

foreach 并非 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。从英文字面意思理解 foreach 也就是“ for 每个”的意思，那么到底怎么使用 foreach 语句呢？

语法：

咱们分别使用 for 和 foreach 语句来遍历数组

运行结果：

看到 foreach 的方便了吧！！

留个思考问题给你们：若是想在 foreach 语句中获取数组元素的下标，该如何作呢？？

6.5Java 中的二维数组

所谓二维数组，能够简单的理解为是一种“特殊”的一维数组，它的每一个数组空间中保存的是一个一维数组。

那么如何使用二维数组呢，步骤以下：

一、声明数组并分配空间

或者

如：

二、赋值

二维数组的赋值，和一维数组相似，能够经过下标来逐个赋值，注意索引从 0 开始

也能够在声明数组的同时为其赋值

如：

三、处理数组

二维数组的访问和输出同一维数组同样，只是多了一个下标而已。在循环输出时，须要里面再内嵌一个循环，即便用二重循环来输出二维数组中的每个元素。如：

运行结果：

须要了解的：在定义二维数组时也能够只指定行的个数，而后再为每一行分别指定列的个数。若是每行的列数不一样，则建立的是不规则的二维数组，以下所示：

运行结果为：

7、方法

7.1如何定义 Java 中的方法

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

通常状况下，定义一个方法的语法是：

其中：

一、访问修饰符：方法容许被访问的权限范围，能够是 public、protected、private 甚至能够省略，其中 public 表示该方法能够被其余任何代码调用，其余几种修饰符的使用在后面章节中会详细讲解滴

二、返回值类型：方法返回值的类型，若是方法不返回任何值，则返回值类型指定为 void ；若是方法具备返回值，则须要指定返回值的类型，而且在方法体中使用 return 语句返回值

三、方法名：定义的方法的名字，必须使用合法的标识符

四、参数列表：传递给方法的参数列表，参数能够有多个，多个参数间以逗号隔开，每一个参数由参数类型和参数名组成，以空格隔开

根据方法是否带参、是否带返回值，可将方法分为四类：

Ø 无参无返回值方法

Ø 无参带返回值方法

Ø 带参无返回值方法

Ø 带参带返回值方法

7.2无参无返回值方法的使用

若是方法不包含参数，且没有返回值，咱们称为无参无返回值的方法。

方法的使用分两步：

第一步，定义方法

例如：下面代码定义了一个方法名为 show ，没有参数，且没有返回值的方法，执行的操做为输出 “ welcome to imooc. ”

注意哦：

一、方法体放在一对大括号中，实现特定的操做

二、方法名主要在调用这个方法时使用，须要注意命名的规范，通常采用第一个单词首字母小写，其它单词首字母大写的形式

第二步，调用方法

当须要调用方法执行某个操做时，能够先建立类的对象，而后经过 对象名.方法名(); 来实现（关于类和对象的概念在后面章节中会详细讲解滴，先熟悉语法，表着急哦~~）

例如：在下面的代码中，咱们建立了一个名为 hello 的对象，而后经过调用该对象的 show( ) 方法输出信息

运行结果为： welcome to imooc.

public class HelloWorld {
    
    public static void main(String[] args) {
		// 建立对象，对象名为hello
		HelloWorld hello = new HelloWorld();
        
		// 调用方法
		hello.showMyLove();
		
	}

	/*
	 * 定义无参无返回值的方法
	 */
	public   void    showMyLove() {
		System.out.println("我爱慕课网!");
	}
}

7.3无参带返回值方法的使用

若是方法不包含参数，但有返回值，咱们称为无参带返回值的方法。

例如：下面的代码，定义了一个方法名为 calSum ，无参数，但返回值为 int 类型的方法，执行的操做为计算两数之和，并返回结果

在 calSum( ) 方法中，返回值类型为 int 类型，所以在方法体中必须使用 return 返回一个整数值。

调用带返回值的方法时须要注意，因为方法执行后会返回一个结果，所以在调用带返回值方法时通常都会接收其返回值并进行处理。如：

运行结果为： 两数之和为：17

不容忽视的“小陷阱”：

一、若是方法的返回类型为 void ，则方法中不能使用 return 返回值！

二、方法的返回值最多只能有一个，不能返回多个值

三、方法返回值的类型必须兼容，例如，若是返回值类型为 int ，则不能返回 String 型值

7.4带参无返回值方法的使用

有时方法的执行须要依赖于某些条件，换句话说，要想经过方法完成特定的功能，须要为其提供额外的信息才行。例如，现实生活中电饭锅能够实现“煮饭”的功能，但前提是咱们必须提供食材，若是咱们什么都不提供，那就真是的“巧妇难为无米之炊”了。咱们能够经过在方法中加入参数列表接收外部传入的数据信息，参数能够是任意的基本类型数据或引用类型数据。

咱们先来看一个带参数，但没有返回值的方法：

上面的代码定义了一个 show 方法，带有一个参数 name ，实现输出欢迎消息。

调用带参方法与调用无参方法的语法相似，但在调用时必须传入实际的参数值

例如：

运行结果为： 欢迎您，爱慕课！

不少时候，咱们把定义方法时的参数称为形参，目的是用来定义方法须要传入的参数的个数和类型；把调用方法时的参数称为实参，是传递给方法真正被处理的值。

必定不可忽视的问题：

一、调用带参方法时，必须保证明参的数量、类型、顺序与形参一一对应

二、调用方法时，实参不须要指定数据类型，如

三、方法的参数能够是基本数据类型，如 int、double 等，也能够是引用数据类型，如 String、数组等

四、当方法参数有多个时，多个参数间以逗号分隔

7.5带参带返回值方法的使用

若是方法既包含参数，又带有返回值，咱们称为带参带返回值的方法。

例如：下面的代码，定义了一个 show 方法，带有一个参数 name ，方法执行后返回一个 String 类型的结果

调用带参带返回值的方法：

运行结果为： 欢迎您，爱慕课！

7.6方法的重载

问：什么是方法的重载呢？

答：若是同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不一样的方法，则称为方法的重载，也可称该方法被重载了。以下所示 4 个方法名称都为 show ，但方法的参数有所不一样，所以都属于方法的重载：

问：如何区分调用的是哪一个重载方法呢？

答：当调用被重载的方法时， Java 会根据参数的个数和类型来判断应该调用哪一个重载方法，参数彻底匹配的方法将被执行。如：

运行结果：

判断方法重载的依据：

一、必须是在同一个类中

二、方法名相同

三、方法参数的个数、顺序或类型不一样

四、与方法的修饰符或返回值没有关系

public class HelloWorld {
    public static void main(String[] args) {

		// 建立对象
		HelloWorld hello = new HelloWorld();

		// 调用无参的方法
		hello.print();

		// 调用带有一个字符串参数的方法
	    hello.print("imooc");

		// 调用带有一个整型参数的方法
	    hello.print(18);
	}

	public void print() {
		System.out.println("无参的print方法");
	}

	public void print(String name) {
		System.out.println("带有一个字符串参数的print方法，参数值为：" + name);
	}

	public void print(int age) {
		System.out.println("带有一个整型参数的print方法，参数值为：" + age);
	}
}

编程练习1:

编写一个JAVA程序，建立指定长度的 int 型数组，并生成 100 之内随机数为数组中的每一个元素赋值，而后输出数组

要求：

一、要求经过定义带参带返回值的方法来实现

二、经过参数传入数组的长度（例如长度为 8），方法执行后返回赋值后的数组

三、经过 (int)(Math.random() * 100) 生成 100 之内的随机数

注：Math 类是用于进行算术操做的类，Math.random() 生成 0--1 的浮点数。关于该类的其余应用在后面章节会有详细介绍，先熟悉随机数方法的使用~~

//导入java.util.Arrays;
import java.util.Arrays;


public class HelloWorld {
    public static void main(String[] args) {
        
         // 建立对象，对象名为hello
    	HelloWorld hello = new HelloWorld();
        
        // 调用方法并将返回值保存在变量中
		int[] nums = hello.getArray(8);
        
        // 将数组转换为字符串并输出
		System.out.println(Arrays.toString(nums)); 
	}

	/*
	 * 功能：建立指定长度的int型数组，并生成100之内随机数为数组中的每一个元素赋值
	 * 定义一个带参带返回值的方法，经过参数传入数组的长度，返回赋值后的数组
	 */
	public int[] getArray(int length) {
        // 定义指定长度的整型数组
		int[] nums = new int[length];
        
        // 循环遍历数组赋值
		for (int i=0;i<nums.length;i++                                    ) {
            
			// 产生一个100之内的随机数，并赋值给数组的每一个成员
		    nums[i]=(int) (Math.random()*100);
        
		}
		return nums; // 返回赋值后的数组
	}
}

编程练习2：

使用eclipse进行程序调试：

双击

debug

调试视图

编程进阶练习：

1. java 入门1
2. 1.Java 入门
3. 1.Java入门
4. Day01 JAVA入门-1
5. java nio - 1 入门
6. JAVA入门3-1
7. java多线程入门1
8. JAVA入门笔记（1）
9. Java 异常入门(1/2)
10. 第1章：Java的入门
更多相关文章...
• Memcached入门教程 - NoSQL教程
• Neo4j数据库入门教程 - NoSQL教程
• YAML 入门教程
• Java Agent入门实战（一）-Instrumentation介绍与使用