并非所有的计算机都可以开发java程序,java程序的开发与运行需要专门的环境。
因为java语言的程序是运行在java所专有的系统中。
-
要运行java程序我们需要在操作系统(windows,MACOS,Linux)安装jre(Java Runtime Environment,简称JRE)。
-
要编译(开发)java程序,我们就需要安装JDK(Java Development Kit)。
jre和JDK都是一个软件,jre这个软件可以运行java编译后的程序。JDK中包含了JRE,JDK中不止有JRE还有java程序的编译软件。我们作为java程序员,只要安装JDK即可。
[1]安装JDK
关键的步骤:
安装完成之后,会在安装的目录中产生一个文件夹:
java目录中有一个JDK和JRE,查看JDK的目录下的内容:
[2]配置环境变量
我们要使用 java -version
查看当前的JDK的版本。
打开命令窗口:
①在运行中输入CMD,回车。
②按键盘上的win键+R键。
所有的命令窗口默认都是在C盘,
我们需要连接几个简单dos命令。
-
盘符切换 : 进入任何和一个盘符, 都是使用
盘符名称:
比如 :D :
-
进入某一个目录: cd 目录名称
我们要执行java命令,就要进入jdk的bin目录。
因为命令本身也是一段程序,所有要运行这个命令,必须能找到这个命令,所以我们要进入JDK的bin目录才能执行java的命令。
我们不可能每次执行java程序都要进入这个bin目录,所以要配置环境变量,环境变量的作用就是让操作系统可以在任何位置都能找到java的命令。
配置环境变量开始:
新建用户变量或者系统变量
修改PATH变量
新建编辑环境变量
测试运行环境和编译环境的版本:
java语言的介绍
-
java语言是所有的面向对象语言的带头大哥。
-
java语言是目前位置跨平台做的最好的一门语言。
java语言的运行
第一个java程序:
在任何位置创建一个记事本文件,后缀修改为.java
我这里的命名是Hello.java
在其中编写如下内容:
public class Hello{
public static void main(String []args){
System.out.println("Hello Java!");
}
}
保存文件之后,在文件所在的目录进行编译。使用命令 javac 文件名,
运行字节码文件 : java Hello
第一个java程序的几个问题:
-
源文件的后缀必须是.java
-
源文件的名字最好是英文,所有的单词的首字母最好大写。
-
程序中的类名和文件名必须完全一致
-
java语言是严格区分大小写的,所以该大写的字母一定要大写。
-
所有的标点符号必须是英文状态输入。
-
每一句程序结束了必须使用“;”结尾。
java程序的运行过程
java程序三步走:
①编写源程序。 所谓源程序就是我们编写的.java文件。里面的内容是程序员看得懂。
②编译远程。 使用 javac
命令将源程序编译成字节码文件(.class文件)。java程序是运行在JVM上的,JVM只认识字节码文件。
③执行java字节码文件。 使用java
命令执行java字节码文件。
JVM
JVM本身是一个软件,在jre中就有JVM。
这台电脑使用的JVM是:
java语言一个非常重要的特性就是跨平台。
所谓跨平台,就是我们在任何一个操作系统中将java源程序编译成字节码文件,然后这个字节码文件可以在任何其他的操作系统中正常运行。
java语言如何跨平台:
java语言跨平台就是通过JVM实现,java程序是运行在JVM上的,和操作系统本身是没关系。JVM就像一个花盆,java程序就好像花盆中的一颗植物。这棵植物只关心花盆,不关心花盆在哪里。
不同的操作系统上有不同的JVM。这个写JVM对java程序的解释是一样的。
所以Oracle为每一个不同的操作系统都提供了专门的JVM。我们现在所说的JVM只是一个规范(标准)。
目前市面上最流行的JVM就是HotSpot。就是全是的java的解释器就只有HotSpot。这就是它规范的原因。
开发工具
java程序的开发工具:
常见的开发工具:记事本、eclipse(免费的)、IDEA(可以试用一个月)、NetBeans........
java语法语法基础
Hello程序的说明
我们的第一个java程序:
public class Hello {
public static void main(String[] args) {
System.out.println("Hello Java!");
}
}
java程序的最小阻止单元是"类" (class)。
在java文件中(.java结尾)编写java类。
在Hello.java文件中的写法:
public class Hello
是固定写法。这里Hello称之为类名,类名必须和文件名完全一致。public和class 是固定的关键字。类中的程序要写在一对{}
上面类中的:
public static void main(String[] args) {
System.out.println("Hello Java!");
}
称之为主函数,主函数的签名: public static void main(String[] args)
固定写法!!!。
主函数中要执行的程序要写在一对{}
中。 我们目前写的就是在控制台输出“Hello Java”。
基本结构:
类和主函数之间,主函数和要执行的程序之间都是有缩进的。这个缩进是一个制表符。任何一个结构的开始的{
都是在语句的后面,结束的"}"都是在下面的。
数据类型
为什么要有数据类型?
我们认知周边的事物就是分类识别,同样计算机要处理数据,也是分类处理数据,所有就有了数据类型。
java中的数据类型:
java中的8中基本数据类型:
-
byte 字节型。 在内存中占8个bit。 表示范围是 -128 ~127
-
shrot 短整型。 在内中占2个字节。16个bit。 -32768 ~ 32767
-
int 整形。 在内存中占4个字节。 32个bit。-2147483648 ~ 2147483647
-
long 长整型。在内存中占8个字节。64个bit。-9223372036854775808 ~ 9223372036854775806
-
float 浮点型。在内存中占4个字节。32个bit。1.4E-45 ~ 3.4028235E38
-
double双精度型。在内存中占8个字节。64个bit。4.9E-324 ~ 1.7976931348623157E308
-
char字符型。表示"一个"字符。在内存中占2个字节。16个bit。 0~ 65535
-
boolean布尔型。表示true或者false。在内存中理论上占一个bit位。 在java中boolean的值只有true和false。
特殊的引用类型:String 表示字符串。多个字符:“Hello”。
变量
变量是存储数据的最小单元。
java语言是强数据类类型,申明变量的时候必须注名变量要存储的数据类型。申请之后,变量的类型不能随意改变。
申请变量的语法:
数据类型 变量名;
给变量赋值依然是使用赋值运算符=
:
变量名 = 变量的值 ;
//申请的同时赋值
数据类型 变量名 = 变量的值;
使用变量的时候,直接使用变量的名称即可。
案例:
public class Demo1 {
public static void main(String [] args){
// 申请变量
int age;
// 给变量赋值(不同数据类型,赋值方式不一样)
age = 18; // 整形直接写数字即可。
// 申请的同时赋值
double score = 86.9; // double类型的直接写数字即可。
// 使用变量输出这两个变量值
System.out.println(age);
System.out.println(score);
}
}
不同类型的变量的赋值方式:
// 不同类型的变量的赋值方式
// byte类型, 数字,注意范围不要超过byte的范围
byte b = 127;
// short,数字,主要范围不要超过short范围
short s = 32000;
// int类型 数字,主要范围不要超过int范围
int i = 65432656;
// long类型,数字,注意如果数字超过了int的范围,则需要使用"L/l"表示当前数字是长整型
long l = 2111111111111110L;
// 字符型 单个字符,必须使用单引号包裹
char ch = '男';
// 浮点型 如果赋值是小数,必须有后缀"F/f"。
float f = 12.0F;
// 双精度型 数字,直接写。 可以在后面使用"D/d"。
double d = 12.5;
// boolean类型。 在java中boolean只有true或者false。
boolean flag = true;
// 非基本类型的String 类型的名字是String,赋值要使用双引号
String name = "旗木卡卡西";
命名规则和规范
类名,变量名的命名规则:(绝对不能触犯)
-
不能以数字开头
-
不能有特殊符号
-
不能是java的关键字或者保留字符。
类名,变量名的命名规范:
-
所有类名 单词的首字母必须大写 Demo
- 所有的变量名 第一个单词全部小写,其余单词的首字母必须大写 firsrName
-
如果是缩写,类名则全部大写,变量名则全部小写
-
言简意赅。
-
尽量使用英文单词,如果是拼音,不允许使用拼音和英文的混合。千万不要使用拼音缩写。更不要使用中文。
数据类型转换
所谓数据类型转换,就是各种不同的数据类型之间的转换。
问题:不同的数据类型在内存中的所占的bit位是不一样的。那么数字 10 在内存中占多少bit位?
理论上数字10只需要4个bit位(1010)。但是数字10有不同的类型:
byte b = 10;
short s = 10;
int i = 10;
long l = 10;
float f = 10;
double d = 10;
上面的定义在内存中的情况:
任何一个类型在无论数值多大,在内存中占的位置大小是固定的。
我们将任何一个byte类型的数据直接赋值给int类型,是否行得通?
byte x = ???; int i = x;
其实就是任何小的类型到大的类型都是自动转换的。
还有一个特殊的情况就是: char可以自动转换为int。
看图记忆:
几个问题:
给长整型赋值:
当我们写任何整形数字的时候,如果没有任何修饰(后缀)。 这个数字默认是int类型。
如果是将这个数字赋值给byte或者short,则默认会转换为对应的类型,当然范围必须在对应的类型的范围内。
byte x = 10; short s = 100;
但是如果将整形数字赋值给长整型变量,这个数字则默认就是整形的。如果超过了整形的范围,就会报错,必须使用"L"标明是长整型。
long l = 21111111110L;
给float赋值:
float f = 12.5;
所有的小数在默认情况下都是double。所以当给float的变量赋值小数的时候,必须使用"F"后缀。
小的类型到大的类型是自动转换的,那么大类型能否转换小类型。
计算机认为将int转换为short的时候,空间放不下,可能会丢失数据。我们知道不会丢失,所以我们可以强制转换。
语法:[目标类型就是我们要转换成的类型,源数据就是原始的数据]
目标类型 变量名 = (目标类型)源数据。
int x = 10; // 强制类型转换 short s2 = (short)x;
上面的案例中是没有数据丢失的。
double d = 12.5; // 强制类型转换 int a = (int)d; System.out.println(a);
上面的强制类型转换会导致小数部分直接被丢弃。
基本类型和字符串之间的转换
任何类型转换为字符串 都可以使用 : xxxx + ""
字符串转换为其他类型:
[1]字符串转换为整形
前提是字符串必须是整数形式的字符串,比如: "128","369"。
操作语法:
String age = "20"; // 使用Integer.parseInt(str) 将字符串转换为数字 int age_ = Integer.parseInt(age); System.out.println(age_);
如果字符串格式不争取,则会报错:
[2]转换为Float或者Double或者Short或者byte或者......
String str = "10"; byte b1 = Byte.parseByte(str); short s3 = Short.parseShort(str); long ll = Long.parseLong(str); float f1 = Float.parseFloat(str); double d1 = Double.parseDouble(str); // 取出字符串中的某一个字符, 其中0就索引。 char ch = str.charAt(0); String bstr = "false"; boolean flag = Boolean.parseBoolean(bstr);
语句
控制台的输出语句,纯粹的为了方便我们学习,在实际工作中,几乎没啥用。
固定的语法:
System.out.print();// 输出不换行 System.out.println();// 输出且换行
// 直接输出一个字符串,并且换行 System.out.println("今天天气不太好!"); System.out.println("的确不太好"); // 输出字符串,但是不换行 System.out.print("这是第一行,"); System.out.print("还是第一行"); System.out.println();// 输出一个空的换行 // 可以输出任何类型的数据 System.out.println('帅'); System.out.println(15); System.out.println(15L); System.out.println(12.5); System.out.println(true); // 可以在()中使用“+”连接任何类型和字符串 System.out.println("小明的名字是:" + "小明"); System.out.println("小明的成绩是:" + 89); // 如果是两个数字,”+“可能会出现数学运算 System.out.println(5+6); // 任何变量都不需要双引号,可以直接输出或者使用"+"连接 String name = "旗木卡卡西"; int age = 28; System.out.println(name + "的年龄是" + age); int x = 3;int y = 4; int temp = x ; x = y; y = temp; System.out.println("x = " + x); System.out.println("y = " + y);
在输出语句中还有一些特殊的符号
在字符串中可以使用\n
表示换行。 可以使用\t
表示一个制表符。可以使用\\
表示一个\
看案例:
// \n表示换行 System.out.println("你好!\n 今天天气不错!"); System.out.println("张三\t李四\t王五"); System.out.println("我的程序在C:\\code下"); // 输出一个成绩表 System.out.println("姓名 语文 数学 英语"); System.out.println("张三 80 89 85"); System.out.println("张三丰 80 89 85"); System.out.println("卡卡西 80 89 85"); System.out.println("-------------------"); System.out.println("姓名\t语文\t数学\t英语"); System.out.println("张三\t80\t89\t85"); System.out.println("张三丰\t80\t89\t85"); System.out.println("卡卡西\t80\t89\t85");
运算符
[1]算数运算符
+,-,*,/,% ,++,--
但是在强数据类型的语言中,一个表达式的最终的结果取决于这个表达式中类型最大的操作数。
案例:
int x = 5,y = 2;
double z = x / y;
System.out.println("z = " + z);// 2.0
得到的z是2.0而不是2.5。 就是因为x和y都是int类型。所以结果会强制转换为int类型。
案例:
int a = 5;
double b = 20.0 / 5;
应用问题:总共有168条数据。计划每页放20条数据,请计算总共需要多少页?
//总共有168条数据。计划每页放20条数据,请计算总共需要多少页?
int total = 168;
int size = 20;
//int maxPageNum = total % size == 0 ? total / size:(total / size + 1);
int maxPageNum = (int)Math.ceil(total * 1.0 / size);//ceil() 方法执行的是向上取整计算,它返回的是大于或等于函数参数,并且与之最接近的整数。
System.out.println("最大页码是:" + maxPageNum);
总结:
下面的情况: 后面的表达式中有double类型的操作,前面的变量是int类型,无法接收。
int m = 10 + 2 / 5 * ( 1.2 * 5);
解决方案:
①将对应的double类型的操作数强制转换为int
int m = 10 + 2 / 5 * ( (int)1.2 * 5);
②将整个表达式的结果强制转换为int
int m = (int)(10 + 2 / 5 * ( 1.2 * 5));
[2]关系运算符
>,>=,<,<=,==,!=
java中没有 ===
和 !==
任何一个表达式中如果出现了比较运算符,则整个表达式的结果肯定是一个布尔值。
[3]逻辑运算符
!,&&,||
***问题:&和&&有什么区别?
&&和|| 有短路作用。 在java中&
和|
也可以做逻辑运算,但是没有短路作用。
案例:
int x = 3,y = 4; boolean flag = x > 3 && (y = 5) > 4; System.out.println(flag); System.out.println("x = " + x); System.out.println("y = " + y);
当我们使用"&&"的时候,最终的结果中flag = false,x = 3,y = 4。
当我们将“&&”修改为“&”的时候,flag = false, x = 3, y = 5;
[4]赋值运算符
=,+=,-=,*=,/=,%=
[5]三目运算
当表达式1的结果为true的时候,整个表达式的结果是表达式2的结果否则是表达式3的结果
表达式1?表达式2:表达式3;
应用:找出两个数中较大的一个数。
int m = 5,n = 7; int max = m > n ? m : n; System.out.println(max);
流程控制
分支流程
[1]if系列
if(表达式){if语句;}
if(表达式){if语句}else{else语句}
if(表达式){if语句}else if(表达式){elseif语句}....[else]
上面的分支语句的语法中所有的表达式都必须是布尔类型的。
在JS中if(表达式)会自动转换布尔值。但是在java中不行的。
[2]switch
switch(表达式){ case value1: statement1; break;// 可选 case value2: statement2: break; ..... default: statement; }
在JDK1.7之前switch中的表达式只能是int或者char类型或者枚举。不能是任何其他类型。
在JDK1.7之后,新增了String。
循环流程
[1]while(){}
要注意的是:()中的表达式必须是布尔值。
java中的while往往使用来做不知道循环次数的循环,或者死循环。
问题:录入学身的成绩,并且计算平均分。
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int score = 0; int sum = 0; int count = 1; while(true){ System.out.println("请录入第"+count+"位同学的成绩(输入-1表示结束):"); score = sc.nextInt(); if(score == -1){ break; } sum += score; count++; } System.out.println("总共录入了"+count+"位同学的成绩,平均分为:"+(sum / count)); }
[2]do{}while();
表达式也必须是布尔值。和while的区别就是肯定至少会执行一次。
[3]for(;;){}
for(;;){} for(表达式1;表达式2;表达式3){
循环语句
}
第一次进入for循环的时候,首先执行表达式1,在判断表达式2,如果是true执行循环语句,如果是false就退出循环。
当循环语句执行结束之后,执行表达式3,继续判断表示2的结果,根据结果进入下次循环或者退出循环。
for(int i = 0;i< 10;i++){ System.out.println(i); }
[4]break和continue
break:跳出整个循环。
continue:结束本次循环,继续下次循环。
控制台输入
我们可以使用System.out.print()在控制台输出任何内容。
我们也可以使用System.in.read()在控制台录入任何内容。
java提供了一个专门的类,Scanner,这个Scanner可以从控制台录入任何基本数据类型。
用法:
// ①引入Scanner包 import java.util.Scanner; public class Demo{ public static void main(String[] args) { // ②创建一个Scanner对象 Scanner sc = new Scanner(System.in); // ③录入数据 // 录入一个字符串 System.out.println("请输入您的姓名:"); String name = sc.next();// 读取字符串 System.out.println("请输入您的年龄:"); int age = sc.nextInt();// 读取控制台的整形数字 System.out.println("姓名:"+name+"\n年龄:"+age); } }
注意的事情:
[1]sc.next() 按照 空字符 截断字符串
如果输入内容如下:
旗木 卡卡西
只能读取到旗木
而 卡卡西
会进入下一个API的调用(可能会报错)。
如果一行的输入中一定是有空格的,则可以使用sc.nextLine();
[2]读取控制台的数字 :
-
sc.nextInt()
-
sc.nextDouble()
-
sc.nextFloat()
当使用这些API的时候,输入的格式必须正确,否则就会报异常:
变量作用域
所谓变量的作用域就是这个变量从申明到结束。(这个变量可以使用的位置)
java 中变量的作用域就是从变量的申明开始,到离这个变量最近的结束的“}”结束。
public class Demo6 { // 成员变量,作用域是在整个类中。 static String name = "这是一个成员变量"; public static void main(String[] args) { // 局部变量 在main方法中使用 int x = 10; if (x > 5){ // 局部变量,只能在if语句块中使用。 int z = 100; } // 变量a和y 都只能在for循环中使用 // a在整个循环中都可以使用。 // y 每次循环都会创建一个新的。 for(int a = 0;a > 10; a --){ int y = 1000; System.out.println("0"); } // 如果要在main方法中使用成员变量,则成员变量必须使用static修饰。 System.out.println(name); } }
双层循环
问题1:在控制台输出矩形
public class Demo7 { public static void main(String[] args) { /** * ***** * ***** * ***** * ***** * ***** */ for(int i = 0;i < 5 ; i ++) { // 控制行 for(int j = 0;j < 5;j ++) { // 每行显示的个数 System.out.print("*"); } System.out.println();// 換行 } // for(int i = 0;i < 5 ; i ++) { // System.out.print("*"); // System.out.print("*"); // System.out.print("*"); // System.out.print("*"); // System.out.println("*"); // } // for(int i = 0;i < 5 ; i ++) { // System.out.println("******"); // } // System.out.println("******"); // System.out.println("******"); // System.out.println("******"); // System.out.println("******"); } }
问题2: 在控制台输出一个正三角形
/** * 双层循环 * * * ** * *** * **** * ***** */ public class Demo8 { public static void main(String[] args) { for (int i = 0;i < 5;i ++){// 5行 // 当j < i + 1的时候,随着行的变量 i + 1 正好是 1~5的变化 for(int j = 0;j < i + 1 ;j ++){ // 控制每行的个数 System.out.print("*"); } System.out.println();// 换行 } } }
问题3: 输出如下的图形
* ** *** **** *****
public class Demo9 { public static void main(String[] args) { for (int i = 0;i < 5;i ++){// 5行 // 一进来,每一行就开始了。 // 先输出空格 空格的个数的变化是 4,3,2,1,0 for(int j = 0;j < 5 - i - 1 ;j ++){ // 控制每行的个数 System.out.print(" "); } // 然后输出* 个数变化 1,2,3,4,5 // 当j < i + 1的时候,随着行的变量 i + 1 正好是 1~5的变化 for(int j = 0;j < i + 1 ;j ++){ // 控制每行的个数 System.out.print("*"); } System.out.println();// 换行 } } }
问题4:输入如下的图形
* *** ***** ******* *********
解决方案1:
public class Demo10 { public static void main(String[] args) { for (int i = 0;i < 5;i ++){// 5行 // 一进来,每一行就开始了。 // 先输出空格 空格的个数的变化是 4,3,2,1,0 for(int j = 0;j < 5 - i - 1 ;j ++){ // 控制每行的个数 System.out.print(" "); } // 然后输出* 个数变化 1,2,3,4,5 // 当j < i + 1的时候,随着行的变量 i + 1 正好是 1~5的变化 for(int j = 0;j < i + 1 ;j ++){ // 控制每行的个数 System.out.print("*"); } // 每一行增加的*的个数变化是 0,1,2,3,4 for(int j = 0;j < i;j ++){ // 控制每行的个数 System.out.print("*"); } System.out.println();// 换行 } } }
解决方案2:
public class Demo11 { public static void main(String[] args) { for (int i = 0;i < 5;i ++){// 5行 // 输出空格 4,3,2,1,0 for(int j = 0 ; j < 5 - i -1; j ++){ System.out.print(" "); } // 输出* 1,3,5,7,9 for(int j = 0;j < 2 * i +1;j++){ System.out.print("*"); } System.out.println();// 换行 } } }
算法问题1:
1,1,2,3,5,8,13,21,34.......循环计算第56位是多少?
/** * 已知 斐波拉契数列(兔子数列)的第一位和第二位都是1,请计算第56位是多少? */ public class Demo12 { public static void main(String[] args) { long a =1,b = 1; for(int x = 3; x <= 56;x ++){ // 计算下一个数 long m = a + b; System.out.println("第"+x+"位是"+m); // b赋值给a,m赋值给b a = b; b = m; } } }
数组
变量就是在内存中开辟一个空间,存储一个数据,然后给这个空间起一个别名。他们和在一起就是一个变量。
数组就是在内存开辟一组连续的空间,这组连续的空间的格式是一致的。给这组连续的空间一起起一个别名。给每个空间给上编号。他们和在一起就是一个数组。
数组的几个特点:
-
在内存中是连续的空间,每个空间都有对应的索引。索引都是从0开始的。
-
一个数组中的数据类型都是一致的。
-
数组一旦初始化,长度是不能改变的。
数组的初始化和简单使用
[1]数组的申明和初始化
在java中数组使用 []申明,语法
[]在数组名的前面或者后面都可以,但是一般写在数组名的前面 。 数组名的命名要求和变量名的命名要求完全一致。
案例:
// 申明数组 int [] scores; String [] names;
数组的初始化:语法
方式1:
数组名 = new 数据类型[length]; // 这里的length必须存在,是整形
方式2:
数组名 = new 数据类型[]{"卡卡西","佐助","鸣人"} // 直接给数组元素赋值的情况下,千万不要写length
方式3:
// 申明数组的同时初始化 数据类型 [] 数组名 = {25,68,98,54,56} // 直接使用{}给数组赋值,但是这种方式只能使用在申明的同时就初始化的情况。
案例:
// 初始化 scores = new int [5]; // scores中的5个元素的默认值都是0 names = new String[]{"卡卡西","佐助","小丸子"};// 不要写长度 // 申明数组的同时初始化 double [] ds = {12.5,12.3,12.6};
当我们使用方式1创建了一个数组的时候,这个数组是有默认值的。
String [] names = new String[10]; // 这个数组的默认值是 null。
各种不同的数据类型的数组的默认值是:
-
byte [] 默认值 0
-
short [] 默认值 0
-
int [] 默认值 0
-
long[] 默认值 0L
-
float [] 默认值 0.0F
-
double [] 默认值 0.0D
-
char [] 默认值
\u000
其实就是一个空字符 -
boolean [] 默认值是 false。
-
其他类型 数组 默认值全部是 null。
[2]数组的使用
tips:在java中数组元素的索引只能是int类型。
获取指定索引的元素:
String name = 数组名[index];
给指定索引的元素赋值:
数组名[index ] = "哈哈";
获取数组的元素个数
int length = 数组名.length;
tips:在java中任何使用我们使用的数组的索引超过了数组元素的索引界限时,都会抛出异常。
案例:
public class Demo14 { public static void main(String[] args) { // 申明数组 int [] scores; String [] names; // 初始化 scores = new int [5]; // scores中的5个元素的默认值都是0 names = new String[]{"卡卡西","佐助","小丸子"};// 不要写长度 // 申明数组的同时初始化 double [] ds = {12.5,12.3,12.6}; // 数组的简单使用 String [] ns = new String[5]; ns[0] = "大圣"; ns[1] = "二师兄"; ns[2] = "小丸子"; ns[3] = "乔峰"; ns[4] = "虚竹"; // 获取数组的中某一个元素 String name = ns[1]; System.out.println("name-1:"+name); System.out.println("------------------"); for (int i = 0;i < ns.length; i ++){ System.out.println(ns[i]); } } }
冒泡排序
排序是所有算法中最为重要的。在笔试中非常的常见。
笔试题:对如下的数组进行从大到小的排序
int[] arr = {56,86,25,47,98,25,35};
所谓排序是说在程序执行结束之后,内存中的数组修改为如下的样式
int[] arr = {98,86,56,47,35,25,25};
import java.util.Arrays;
/**
* 冒泡
*/
public class Demo2 {
public static void main(String[] args) {
int[] arr = {56,86,25,47,98,25,35};
for(int i = 0; i < arr.length - 1;i ++){// 执行多少轮
for (int j = 0;j < arr.length - 1 - i;j ++){// 内部循环的次数是 逐个递减
// 比较j和j+1两个元素的大小
if(arr[j] < arr[j + 1]){
// 交换两个元素的位置
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
断点调试
找bug:如果程序报错了,根据错误提示可以查找问题所在。如果程序没有报错,就必须猜测问题所在。 断点调试查找问题。bug不是语法错误。
写好程序,在需要调试的位置添加断点:
加好断点之后,右键debug启动。启动之后,程序会暂停在添加断点的位
本文来自博客园,作者:{潇潇消消气},转载请注明原文链接:{https://www.cnblogs.com/xiaoxiaodeboke/}