java初级笔记

---

第一章 Java技术简介

一、Java的性质

1. 简单性
2.*可移植性
3.*面向对象
4.分布式
5.*安全性
6.体系结构中立
7.健壮性
8.解释型
9.高性能
10.*多线程
11.*动态性

面向对象

面向对象，木匠做椅子，先关注的是所制作的椅子而不是工具，非面向对象的，木匠主要先考虑的是所用的工具。
两个基本概念：类，对象
三大特性：封装性，继承性，多态性

可移植性

数据具有固定字节或是格式，移植到其他操作系统时不会发生改变，可在多操作系统上使用。
Java语言是运行在Java虚拟机上（JVM）的，所以在不同操作系统当中，Java在JVM上运行。对于不同的平台有不同的JVM。

动态性

可为正在运行的程序增加代码，不会影响运行中程序的使用，相比于C和C++而言，更加具有动态性，，可以很容易的实现运行程序的演进。

二、关于对Java常见误解的解释

1.Java是HTML的拓展

Java是一种程序设计语言，HTML是一种描述网页结构的方式，二者没有任何共同之处

2.Java是专用的，应避免使用

Java语言是闭源的，但是可以查看，可以很好的使用，在未来不久，Java语言专利到期后，会转为开源，

3.JavaScript是Java的简易版

JavaScript是一种网页中使用的脚本语言，只有名字有些相像，其他并无任何关系

第二章 Java程序设计环境

安装Java开发工具包

1.下载jdk

下载Java开发工具包，可以访问Oracle公司的网站：www.oracle.com/technetwork/java/javase/downloads进行下载，在得到所需软件之前需要明白大量专业术语，例如编写Java程序的程序员使用的软件Java Developmen Kit（jdk）,这就是我们所需要下载的软件专业术语

2.设置JDK

这个可以百度自行搜索

3.设置环境变量

4.测试JDK能否正常使用

1.win+R，输入cmd

2.输入javac.exe 出现如下界面

3.输入java -version 注意中间有空格

（如果输入java -version无反应，可以输入java.exe -version）

出现如下界面

安装成功后，即可使用集成开发软件编写代码了，如果出现错误请重新安装jdk,或者安装低版本jdk

5.使用集成开发环境

我们可以使用一些免费的集成开发软件，例如Eclipse,IntelliJ IDEA,NetBeans等

6.简单的命令行指令应用

dir：列出当前目录下的文件以及文件夹
md：创建目录
rd：删除目录
cd：进入指定目录
cd…：返回至上一级目录
cd\：返回至根目录
del：删除文件
exit：退出dos命令

第三章 Java的基本程序设计结构

一、一个简单Java应用程序应具有的结构

public class Test{public static void main(String[] args){System.out.println("Hello world");
}
}

例如以上简单Java程序，此程序虽然简单，但是所有java程序都应具备这种结构

Java程序结构

1.Java程序中是区分大小写的，如果出现大小写拼写错误，程序将无法运行

2.关键字public成为访问修饰符，这些修饰符用于控制程序的其他部分对于这段代码的访问级别。

3.关键字class表明Java程序中的全部内容包含在类中，class后紧跟类名

4.类名问题：Java中定义类名的规则很宽松，名字必须以字母开头，其后可以添加符号与字母的任意组合，但是不可以使用Java保留字，类名规范为大写字母开头的名词，例如:class Sample,如果类名由多个名词构成，那么应以每个单词的首字母大写定义，例如：class FristSample.

5. 定义Java程序名字后切记不要添加（.class）拓展名，程序执行后会自动添加

6.在以上例子中我们使用了System.out对象并调用了println()方法，注意，点号（.）用于调用方法，Java中使用调用方法的通用语法是object.method(parameters参数)

7.代码中的大括号（{ }）,Java中的任何方法都用 ‘{’开始，用 ’ } ’ 结束。

8.在Java中，每个句子必须用分号（；）结束

9. 执行Java程序是，Java虚拟机总是从指定类中的main方法开始执行，所以为了代码能够执行，必须在类的源文件中必须包含一个main方法，并在main方法中调用这些方法（main方法必须声明为public）

10.在一个java源文件中可可以声明多个class，但是，最多有一个类声明为public的，而且要求声明public的类的类名必须与源文件名相同

11.编译源文件(.java)后或出现一个或多个字节码文件(.class),字节码文件的名称为类名

使用Dos命令运行一个简单的Java程序，输出HelloWorld

Java文件的建立及编译

Java程序是通过将代码编写到.java文件(源文件)中，再由javac.exe进行编译的，编译完成后生成.class文件（字节码文件），最后通过java.exe对生成的.class文件进行运行的。（注：.class文件的命名是在对源文件编译完成后，将源文件中的类名用作于.class文件的名字）。

编译，运行，输出HelloWorld

建立一个.txt文件，命名为Helloworld，更改文件类型为.java类型，这边建立一个Helloworld.java文件，使用记事本打开，如下图输入

打开Dos命令，进入.java文件路径，并输入javac HelloWorld.java进行编译，生成HelloChina.class文件(取名为类名)

输入java HelloChina.class进行运行，最后输出HelloWorld

二、注释

//注释方法以及使用
// 1.单行注释：符号// 在输入//符号后 符号后同行内容不会影响代码运行
//2.多行注释：符号 /* */    在符号/*   */之间的内容会被注释，不影响代码的运行public class Notes {public static void main(String[] args) {System.out.println("hellowrld");//输出helloworld/*     System.out.println("helloworld");System.out.println("helloworld");     在符号中间的内容被注释System.out.println("helloworld");*/}
}

三、数据类型

//
//数据类型：整型(byte，int，short,long) 浮点型(float,double) 布尔型(boolean) 字符型(char)，引用型数据-字符串(String)
//
public class DateType {public static void main(String[] args) {//整型   long>int>short>byteint a=1;short b=2;long c=1000000000000000l; //  长整型之后要加l(L)，输出结果不带L，不加l会默认为int类型，编译不报错//浮点型  double>floatfloat n=0.3f;// float类型之后要加 f或F 否则 则会被默认为是double类型，不加f会默认为double类型double m=0.34;// double类型之后可以选择 加d或D或不添加//布尔型  (整型值与布尔值不能相互转换)boolean one=true;boolean two=false;//布尔型只有两种值//字符型char s='a';// 定义一个字符型 符号是'',内容可以是一个字符，转义字符，Unicode的值//char s=97的值和char s='a'的值相同，因为java语言会自动把97转义为小写字母achar  car='\n';/* 转义可使用转义序列（例如：\b ）或者使用Unicode值转义（例如：\u0008）,这两样都表示退格的意思  Unicode值由 \u加上4个16进制数组成*//*！！！ 在注释中使用小心使用Unicode值，在注释中，打出\u会提示转义错误，在Java中，即使是在注释中，也依旧会自动转义Unicode值，无意中在注释打出\u,或者包含\u的句子会自动转义，最后导致出现错误*/System.out.println("注意Unicode转义在注释后定义转义符号\u等会提示转义错误");//输出结果：转义出错//字符串String ni="wode"; //定义一个字符串 符号是""System.out.println(ni);}
}

四、变量和常量

1.声明变量

//变量(Variable)
//声明一个变量的名字可以定义很多，范围有数字.字母.符号(_,$)
//符号不可单独做一个变量名
//不可使用保留字作为变量名
public class Variable {public static void main(String[] args) {//定义一个变量int a;//定义多个变量int d,e,f;//给变量赋值的方法int b;b=1;//或者int c=1;}
}

变量的作用域，其定义所在的一对{ }中，变量只有在其作用域内有效，同一作用域中，不能重复定义变量的名。

public class Variable{public static void main(String[] args){int num=1;System.out.println(num);Variable2 v=new Variable2();// v 为引用Variable类的对象System.out.println(v.num);//在这里调用variable2类中的num变量//两个相同的变量名，但是其作用域不一样，所以可以使用
}
}
class Variable2{int num=2;}

2.变量的初始化

定义变量的格式：数据类型 变量名 = 变量值；
在Java语言中，声明一个变量要对其进行初始化，如果声明完，没有对其赋值直接进行使用，会出现错误，例如以下

int a;
System.out.println(a);//没有对该变量进行初始化，直接使用会出现错误

声明完变量后，我们应对其进行初始化，如下

//对变量进行初始化的方法有两种
//可以在声明变量的同时直接对变量进行初始化
int a=10;
//也可以在声明变量后进行变量的初始化
int a;
a=10;

变量要先声明并初始化，然后在进行使用，变量的初始化尽量靠变量第一次使用的地方近一些

3.常量

//常量(final)
//定义一个常量用关键字 final
//关键字final表示这个变量只能被赋值一次，赋值后不能更改
//类常量，定义在main方法的外部，类常量可以在一个类的多个方法使用
public class Final {public static final int a=1;//使用static final定义一个类常量,在此类中可以被多个方法使用，添加public可以被其他类使用public static void main(String[] args) {final int b=2;//定义一个常量，此常量的值不可被改变b++;//当尝试改变b的值时会报错System.out.println(b);}
}

4.运算符

//运算符
//算术运算符 + - * /(除)  %(求余)   (也叫二元运算符)
//赋值 和运算符
//自增与自减
//关系运算符
//位运算符
public class Operator{//运算符 + - *  /   %  前++ --、 后++ --  public static void main(String[] args){//除号：int num1=12;int num2=5;int result1=num1 / num2;  System.out.println(result1);  //2int result2 = num1 / num2  * num2;System.out.println(result2);  //10double result3 =num1 / num2;System.out.println(result3);  //2.0double result4 = num1 / num2 + 0.0;  //2.0double result5 = num1 / (num2 + 0.0);  // 2.4System.out.println(result5);double result6 = (double)num1 / num2; //2.4double result7 = (double)num1 /(double) num2; //2.4double result8 = (double)(num1 / num2);     //2.0//取模（求余）//结果的符号与被模数的符号相同//开发中，经常使用%来判断能否被除尽的情况，结果为0被除尽int m1 = 12;int n1 = 5;System.out.println("m1 % n1 ="+m1%n1);  //2int m2 = -12;int n2 = 5;System.out.println("m2 % n2 ="+m2%n2); // -2int m3 = 12;int n3 = -5;System.out.println("m3 % n3 ="+m3%n3); //2int m4 = -12;int n4 = -5;System.out.println("m4 % n4 ="+m4%n4);  // -2
}public class Calculation {public static void main(String[] args) {//赋值 和运算 符int x=1;x=x+4;//或者x+=4 其他算数运算符也是如此x+=3.5;//如果这种写法的两边类型不一致时，就会发生强制类型转换 将其计算结果类型转换成与左边的一致System.out.println("x的值："+x);int num=15;num %= 5;//num = num % 5 System.out.println(num);//0num +=2;//num=2 这种写法不改变数值的类型//自增与自减int z=1,h=2;z=z*h++;//这样会先计算z*h,在计算h=h+1z=z*++h;//这样会先计算h++，再计算z*h//减号与加号同样//注意点：short s1 = 10; //s1 = s1 +1;   编译失败，1为int类型//s1=(short)(s1+1);//正确的s1++;//自增一不会改变本身的数据类型System.out.println(s1);//问题：byte bb1=127;bb1++;System.out.println("bb1:"+bb1);//输出为 -128，加一导致溢出，符号位由零变成一，最后的值为-128//关系运算和boolean，关系运算符返回值是布尔型//检测相等性  可用==    3==7  结果为flase   //检测不相等  可用！=    3！=7 结果为true//注意！！！  要区分=和 == 的区别boolean b1=true;boolean b1=false;System.out.println(b2 == b1); // false  b2与b1不相同System.out.println(b2 = b1); //true  将b1的值赋给b2并输出//还有经常用的 > < >= <= 等// &（判断符号两边的表达式，全真则真）  |（判断两边表达式，一真则真）// &&（与 一假则假，遇到假就为假）  || （或 一真则真）/*三元操作符   条件表达式 ？表达式1：表达式2 例 x<y?x:y//最后用变量来接受结果//int x =(m>n)?m:n;,int x1= 1,y1=2;String max=x1>y1?x1:"y大"; //编译错误，x1为int类型//！！！注意，结果表达式的类型要为同一类型逻辑为 如果条件表达式的值为真 则返回表达式1 假则返回表达式2*///位运算符//括号与与运算符级别// a&&b||c//&&优先级高于|| 等价于 (a&&b)||c//a+=b+=c  +=是右结合运算符 所以等价于a+=(b+=c)先计算b+=c 再用 b+c的值加a}
}

其他位运算符

5.数值类型之间的转换

    //类型转换int n=123456789;float f=n;//在数据类型转换时，高精度向低精度转换会丢失精度System.out.println(f);//输出结果为1.23456792E8int num1=3;float num2=4.56f;System.out.println(num1+num2);/*当二元运算符链接两个值时会先先将两个操作数转换为同一种类型在进行计算以num1+num2为例如果两个操作数中有一个是double类型，另一个就会转变为double类型否则，如果其中一个操作数是float类型，另一个就会转变为float类型否则，如果其中一个操作数是long类型，另一个就会转变为long类型否则，两个操作数都会转变为int类型//当byte,char,short三种变量类型做运算时，结果都为int类型，//float 类*///强制类型转换double xy=9.997; //将double类型强制转换为int类型int nx=(int) xy;//丢失精度 变为整型 nx=9int next=3;float nex=(float)next;//将int类型强制转换为float类型System.out.println(nex);//输出结果为3.0

6.字符串

字符串的定义：

（1）用String定义字符串，（2）给字符串初始化赋值时使用（ " "）

         String a = "hello";//定义一个字符串，用""String b = "study";String c = "Java";String d="Hello";String e=123;//编译错误

子串：

 //子串   用substring方法可以从字符串中提取子串String a = "hello";String s = a.substring(0, 3); //substring从0开始计数，到3为止，但不包括3System.out.println(s);//输出结果为hel

字符串的拼接：

 //字符串拼接String a="hello";String b="我今年";String c="world";String sum = a + c;//字符串拼接中间没空格，+会按照顺序将两个字符串拼接起来System.out.println(sum);//输出结果helloworldint age = 13;String ra = b + age;//当字符串与非字符串类型拼接时，会自动将其转换为字符串类型System.out.println(ra);//输出结果为 我今年13

字符串的修改:

由于String类中并没有提供修改字符串中某个字符的方法，所以想要修改字符串，只可以使用方法进行拼接替换

 //字符串的修改  字符串是不可修改的，所以想要修改字符串只有替换字符串,使用substring方法提取字符串String h ="hello";String New=h.substring(0,3)+"p!";System.out.println(New);//输出结构为help!

字符串的输出

  //直接输出字符串System.out.println("This is my name : 昭浅");////如果想将多个字符串输出，并且使用一个界定符号分开，可以使用静态join方法String all=String.join("/","s","m","l"); //输出结果为 s/m/l//重复输出字符串的方法repeatString repeat="java".repeat(3); //将java重复输3遍System.out.println(repeat);//输出结果为 javajavajava

检测字符串是否相等

  // 用equals方法检测字符串是否相等 相同为true 不相同为falseString a="me";String d="your";System.out.println(a.equals(d));      //直接使用连个变量相比较System.out.println("hello".equals(a));  //用字符串与变量相比较System.out.println(a.equalsIgnoreCase(d)); //两个变量间不分大小写的比较/**！！！ 不可以用==来比较字符串*/

空串与Null串

NULL:代表声明了一个空对象,不是一个字符串,可以赋给任何对象。 空字符:代表声明了一个对象实例,这个对象实例的值是一个长度为0的空字符串

 String a="";//a为空串，长度为0，内容为空的字符串String b=null;//声明一个空对象

五、进制

1.二进制

二进制的整数有如下三种形式
原码：直接将一个数值换成二进制数，最高位是符号位
负数的反码：是对原码按位取反,只是最高位(符号位)确定为1
负数的补码：其反码加1
计算机底层的存储方式：所有的数字在计算机底层都以二进制形式存在。
二进制数据的存储方式：所有的数值，无论正负，底层都以补码的方式存储。

用14 的二进制数来举例说明
这是14的二进制形式：

0	0	0	0	1	1	1	0
最高位为符号位，0：正数，1：负数
这是-14的原码：

1	0	0	0	1	1	1	0
这是-14的反码：
1	1	1	1	0	0	0	1
–	–	–	–	–	–	–	–
这是-14的补码 负数的补码：其反码加1
1	1	1	1	0	0	1	0
–	–	–	–	–	–	–	–

在计算机的底层都以补码的方式来存储数据(无论正负)！
正数的原码，反码，补码是相同的，所以正数可以直接当做数据存储，而负数的补码需要通过负数的原码推至反码，再到补码进行存储(原码→反码→反码)

以此，我们反向思考一下，给了一个二进制的补码，我们应该怎么算出它的原码呢

以下随机用一个二进制数补码来推出原码
这是一个随机二进制数的补码

由此补码减1，我们可得到这个随机补码的反码

再进行除符号位外，取反，我们可得到这个随机补码的原码

最后我们得到这个随机二进制补码的原码：

1符号位	1	0	0	1	0	0	1
这个二进制数的结果为-73

2.二进制转换十进制

举例说明，随机写一个二进制数

转换计算过程为

最终得出结果为14

3.十进制转换二进制

举例说明，随机写一个十进制数 17

将十进制数除二，最后除尽（结果为1）为止，如上图，最后结果取逆，得出结果：17的二进制数为10001

4.二进制与八进制，十六进制之间的转换

在本图中由二进制转换为八进制，可以理解为八是二的三次幂，在所以在本图中可以把三位数当做一个二进制数来处理，推算出从低到高（从右至左），得出三个数字1，5，3
，所以该二进制数转换为八进制数为 0 3 5 1

同理,由二进制转换为十六进制，十六是二的四次幂，在本图中，可把四位数当做一个二进制数处理，最后得到结果分别是 9，E（二进制1 1 1 1是十进制的15，也就是16进制的F）

5.进制之间的转换

以上，我们讲解了二进制到十进制，八进制，十六进制之间的转换，所以，想要四种进制之间的互相转换只需要中间的纽带（二进制）就可以
八进制→二进制：举例八进制数 0357

所以可得该八进制转换为二进制为 011101111
十六进制→ 二进制：举例十六进制数 0x3AF

所以可得该十六进制数转换为二进制为 001110101111

到这里，我们学完了二进制到所有进制之间的转换，也学完了所有进制到二进制之间的转换，通过二进制为纽带，我们可以做到所有进制之间的相互转换。

六.关键字与保留字

1.关键字

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

2.保留字

定义：现有java版本尚未使用，但以后版本可能会作为关键字使用，自己命名标识符时要避免使用这些保留字
具体保留字： goto、const

3.标识符

定义：Java对各种变量、方法和类等要素命名时使用的字符序列成为标识符
技巧：凡是自己可以起名的地方都叫标识符
涉及到的结构:类名、接口名、变量名、方法名、常量名

定义合法标识符规则：必须要遵守，否则编译不通过
（1）由26个英文字母大小写，0-9，_或$组成
（2）数字不可以开头
（3）不可以使用关键字和保留字，但可以包括关键字和保留字
（4）Java中严格区分大小写，长度无限制
（5）标识符不能包含空格
Java中的名称命名规范：
（1）包名：多单词组成时所有字母都小写：xxxyyyzzz
（2）类名、接口名：多单词组成是，所有单词的首字母大写：XxxYyyZzz
（3）变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
（4）常量名：所有字母都大写，多单词时每个单词用下划线链接：XXX_YYY_ZZZ
注意：在起名字时，为了提高阅读性，要尽量有意义，见名知意
Java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用

七.输入与输出

如何从键盘中获取不同类型的变量，需要使用Scanner类

具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化：Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法，来获取指定类型的变量
注意：需要根据相应的方法，来输入指定类型的值，如果输入的数据类型与要求的类型不匹配时，会报异常：InoutMisMatchException,，导致程序终止

import java.util.Scanner;class ScannerTest{public static void main(String[] args){Scanner scan = new Scanner(System.in); //声明一个输入对象scanint num = scan.nextInt();  //调用nextInt()方法，获取键盘中输入的int类型值System.out.println(num); //输出获取的值}
}

!!! 在Sacnner类中 没有提供获取char类型的获取方法，只能获取一个字符串

System.out.println("请输入你的姓名：");  String  name = scan.next();       //输入字符型System.out.println(name);System.out.println("请输入你的年龄：");int age = scan.nextInt();      //输入int类型System.out.println(age);System.out.println("请输入你的体重：");double weight = scan.nextDouble();    //输入浮点型System.out.println(weight);System.out.println("你是否是男生？（true/false）");boolean sex = scan.nextBoolean();System.out.println(sex);       //输入布尔型

八.程序流程控制

流程控制语句是用来控制程序中语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块
其流程控制方式采用结构程序设计中规定的三种基本流程结构，即
顺序结构 ：程序从上到下逐行的执行，中间没有任何判断和跳转

分支结构：根据条件，选择性的执行某段代码

循环结构：根据循环条件，重复性的执行某段代码

分支结构

1.if-else 结构

if语句的三种格式：

 if(x>2)if(x<10)System.out.print(true);else System.out.print(false); //注意，就近原则，与if(x<10)配对

当if else 结构中不加｛｝时，注意上图，else会遵循就近原则，他会与if(x<10)配对，而不是if(x>2)，小心翻车

2.switch-case结构

switch(表达式){   case 常量1 ：语句1；break;case 常量2 ：语句2；break;case 常量3 ：语句3；break;case 常量 4：语句4；break;default:   //defalut语句：当以上case语句都不与表达式相匹配时，就会执行default语句语句；break;
}

switch语句将从与表达式值相匹配的case标签开始执行，直到遇到break语句，或者执行到switch语句的结束处为止，如果没有相匹配的case标签，而有default语句，就执行这个语句

警告：当case语句中没有break语句时，可能会触发多个case语句，在遇到与表达式相同的case语句，程序会从这条case语句执行到以下所有的case语句,这种情况常常会引发错误,如下

     switch(num) {case 1 :System.out.println("这是1");case 2 :System.out.println("这是2");case 3 :System.out.println("这是3");case 4 :System.out.println("这是4");case 5 :System.out.println("这是5");}//不加break，如类似以上代码，会在遇到相匹配的case语句时,一直执行到代码结束//输出结果为  这是3//这是4//这是5//!!!但break不是必加的

case标签可以是：
① char , int , byte , short常量表达式
② 枚举类型
③ 字符串常量
case标签必须是常量表达式，是不可写范围的（例如（x > 2））

1.凡是可以使用switch-case的结构，都可以转换为if-else，反之，不成立。
2.我们写分支结构时，当发现既可以使用switch-case（同时，switch中表达式的取值情况不太多）， 又可以是有if-else时 ，我们优先选择使用switch-case,原因 ：switch-case执行效率高

循环结构

1.for循环结构

for循环的4个要素
一、循环结构的4个要素
1.初始化条件
2.循环条件   -->是boolean类型
3.循环体
4.迭代条件二、for循环的结构
for(1;2;4){3
}执行过程 1->2->3->4->2->3->4-.....

int num = 1;
for(System.out.print('a');num <=3;System.out.print('c'),num++){//迭代条件为两个System.out.print('c')和num++，中间用，（逗号）隔开System.out.print('b');
}
//输出结果为abcbcbc，由此看出执行过程

2.while循环结构

while循环的4个要素
一、循环结构的4个要素
1.初始化条件
2.循环条件   -->是boolean类型
3.循环体
4.迭代条件二、while循环的结构：1;
while(2){3;4;
}
执行过程： 1->2->3->4->2->3->4-.....注意：写while循环千万小心不要丢掉迭代条件，否则会造成死循环，循环算法要有有限性

for循环和while循环可以相互转换，不同点：for循环和while循环初始化条件的作用域不一样

3.do-while循环结构

一、循环结构的4个要素
1.初始化条件
2.循环条件   -->是boolean类型
3.循环体
4.迭代条件二、do-while循环结构
1;
do{3;4;
}
while(2);
执行过程： 1-->3-->4-->2-->3-->4-->.....注意：do-while至少会执行一次循环体

说明： 1.不在循环条件部分限制次数的结构：for(;;)或while(true) 2.结束循环有几种方式？ 方式一：循环条件部分返回false 方式二：在循环体中，执行break

4.嵌套循环

1.嵌套循环： 抢一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环

2.
外层循环：循环结构B
内层循环：循环结构A

说明：
①内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
②假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循 环体一共执行了m*n次
③外层控制行数，内层控制列数

经典练习题： 输出九九乘法表

 for(int i=1;i<=9;i++) {for(int j=1;j<=i;j++) {System.out.print(i+"*"+j+"="+i*j+" ");;}System.out.println();}

九、数组

数组的概述

1、数组的理解

数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理

2、数组相关的概念

>数组名
>元素
>索引（角标）
>数组的长度：元素的个数

3、数组的特点

①数组是有序排列的
②数组属于引用数据类型的变量，数组的元素既可以是基本数据类型，也可以是引用数据类型
③常见数组对象会在内存 开辟一整块连续的空间
④数组的长度一旦确定，就不能改变

4、数组的分类

①按照维数：一维数组、二维数组、…
②按照数组元素的类型，基本数据类型元素的数组、引用数据类型元素的数组

一维数组的使用

1、一维数组的声明和初始化

//声明并定义一个一维数组,数组的长度为三
//
//静态初始化：数组的初始化和数组元素的赋值操作同时进行
int[] array= new int[] {1,2,3};
//动态初始化：数组的初始化和数组元素的赋值操作分开进行
int[] array = new int[3];
// 定义数组的不同方式
int array[] = new int[3];

总结：数组一但定义完成，其长度就确定了

2、数组元素的调用

//定义数组names并为其赋值 数组名[索引]=赋值
String[] names = new String[4];names[0]="decade";names[1]="kuga";names[2]="kubuto";names[3]="w";System.out.println(name[1]);//调用并输出一维数组names中的元素

3、如何遍历数组元素

System.out.println(names.length);//获取数组names的长度//遍历数组names并输出数组元素for(int i=0;i<names.length;i++) {System.out.println(names[i]);

4、数组元素的默认初始化值

>数组元素是整形：0
>数组元素是浮点型：0.0
>数组元素是char型：0或‘\u0000’，而非‘0’
>数组元素是boolean型：false
>数组元素是引用数据类型：null

多维数组的使用

1、二维数组的声明和初始化

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素存在，其实从数组底层的运行机制来看，没有多维数组

//声明并定义一个二维数组
//静态初始化
int[][] arr = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
int[][] arr1 = new int[3][4];
//动态初始化2
int[][] arr2 = new int[3][];//声明一个行长度为3的二维数组
arr2[0] = new int[4];//为二维数组arr2的第0行定义列数为4

2、二维数组元素的调用

int[][] arr1=new int[][]{{1,2,3},{4,5},{6,7,8}};
int[][] arr2 = new int[3][4];
System.out.println(arr1[0][1]);//2  调用并输出二维数组的元素
System.out.println(arr2[0][1]);// 0、null 未负值的数组在使用时的值为0或是null 看数组的类型而定

3、如何遍历二维数组元素

int[][] arr1=new int[][]{{1,2,3},{4,5},{6,7,8}};
System.out.println(arr1.length);//获取二维数组行的长度
System.out.println(arr1[0].length);//获取二维数组第0行的列数
System.out.println(arr1[1].length);//获取二维数组第1行的列数for(int i=0;i<arr1.length;i++){for(int j=0;j<arr1[i].length;j++){System.out.println(arr1[i][j]); }
}

4、二维数组的使用

//规定:二维数组分为外层数组的元素，内层数组的元素int[] arr = new int[3][4];//外层元素 ： arr[0],arr[1]等//内层元素 ： arr[0][0],arr[1][2]等System.out.println(arr[0]); //[I@59906517 输出的结果为第0个外层元素中的值，//外层元素中的值为内层元素的地址System.out.println(arr[0][0]);//0 输出的结果为0//是第0个外层元素中第0个内层元素的值System.out.println(arr); //[[I@5bfbf16f  输出的结果为外层元素的地址  //方括号([)的个数代表存储的是几维数组 I为存储数组的数组类型//特别注意！！int[][] arr1 = new int[3][];System.out.println(arr1[1]);//null 输出结果为null //声明arr1数组时并未声明内层数组的长度，所以并未为其分配空间，//所以外层数组中存的值为null,表示空的地址值System.out.println(arr1[1][1]);//报错，并未为声明内存元素，空指针异常

5、二维数组元素的默认初始化值

针对初始化方式一：例如 int[] arr = new int[3][4];外层元素的初始化值为：地址值内层元素的初始化值为：与一维数组初始化情况相同
针对初始化方式二：例如 int[][] arr1 = new int[3][];外层元素的初始化值为：null内层元素的初始化值为：不能调用，否则报错

数组中涉及的常见算法

1、数组元素的赋值（杨辉三角、回型数）

杨辉三角

//杨辉三角
public class ArrayTest2 {public static void main(String[] args) {int[][] arr= new int[10][];//定义一个外层数组为10for(int i=0;i<arr.length;i++) {arr[i]=new int[i+1];for(int k=1;k<=arr.length-i-1;k++) {System.out.print(" ");}for(int j=0;j<=i;j++){if(j==0 || j==i) {arr[i][j]=1;}else {arr[i][j]=arr[i-1][j-1]+arr[i-1][j];                  }           System.out.print(arr[i][j]+" ");}System.out.println();}}
}

回型数

package Question;
import java.util.Scanner;
//回型数
public class Array1 {public static void main(String[] args) {Scanner scan = new Scanner(System.in);int num=scan.nextInt();int[][] arr = new int[num][num];int i=0,j=0,sum=1;int min=0,max=num-1;while(i<arr.length && j<arr[i].length) {if(i==0 && j==0) {arr[i][j]=sum;if(num==1) {arr[i][j]=sum;break;}}sum++;if(j==max) {if(i!=max) {i++;}}else {if(i==min) {j++;}}if(i==max) {arr[i][j]=sum;if(j==min) {i--;              }if(j>min)j--;}else {arr[i][j]=sum;if(j==min && i>min) {i--;}}if(i==min+1 && j==min) {sum++;arr[i][j]=sum;min++;max--;}if(sum==num*num) {break;}}for(int m=0;m<arr.length;m++) {for(int n=0;n<arr[m].length;n++) {System.out.print(arr[m][n]+"\t");}System.out.println();}}
}

2、求数值型数组中元素的最大值、最小值、平均数、总和等

import java.util.Random;
public class ArrayTest3 {public static void main(String[] args) {Random random = new Random();int[] arr = new int[10];for(int i=0;i<arr.length;i++) {arr[i]=random.nextInt(90)+10;System.out.print(arr[i]+" ");}System.out.println();int max=0,min=100,sum=0;for(int i=0;i<arr.length;i++) {if(max<arr[i]) {max=arr[i];}if(min>arr[i]) {min=arr[i];}sum+=arr[i];}System.out.println("最大值："+max);System.out.println("最小值："+min);System.out.println("平均值："+sum/arr.length);System.out.println("总和："+sum);}
}

3、数组的复制、反转、查找（线性查找、二分法查找）

使用简单数组 数组复制
①创建一个名为ArrayTest的类，在main（）方法中声明array1和array2两个变量，他们是int[]类型的数据
②使用大括号｛｝把array1初始化为8个素数：2,3,5,7,11,13,17,19
③显示array1的内容
④赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值，如（array[0]=0,array[2]=2）打印出array1

思考： array1和array2是什么关系？
答：array1和array2地址值相同，都指向堆空间的唯一的一个数组实体
拓展：怎么实现array2对array1的复制
array2=new int[array1.length];
for(int i=0;i<array2.length;i++){
array2[i]=array1[i];
}

 int[] array1,array2;//①array1=new int[] {2,3,5,7,13,17,19};//②for(int i=0;i<array1.length;i++) {//③System.out.print(array1[i]+" ");}System.out.println();array2=array1;//④  此时赋值是将array1的地址赋值为array2，并没有将array1的值复制。所以操作array2也会改变array1,不能叫做数组的复制for(int i=0;i<array2.length;i++) {if(i%2==0) {array2[i]=i;}System.out.print(array2[i]+" ");}System.out.println();for(int i=0;i<array1.length;i++) {//③System.out.print(array1[i]+" ");}System.out.println();

数组的反转

//数组的练习
//数组的反转练习
public class Array2 {public static void main(String[] args) {//数组的反转String[] arr=new String[] {"a","b","c","d","e","f"};String temp="";int length=arr.length-1;for(int i=0;i<arr.length;i++) {   temp=arr[i];arr[i]=arr[length];arr[length]=temp;length--;if(i==length || i>length) {break;}}for(int i=0;i<arr.length;i++) {System.out.println(arr[i]);}//优化for(int i=0;i<arr.length/2;i++) {String temp1=arr[i];arr[i]=arr[arr.length-1-i];arr[arr.length-1-i]=temp1;}for(int i=0;i<arr.length;i++) {System.out.println(arr[i]);}}
}

查找（线性查找、二分法查找）

遍历查找（线性查找）
String[] arr=new String[]{"a","b","c","d","e"};
String find="c";
boolean isFlag=false;
for(int i=0;i<arr.length;i++){if(find.equals(arr[i])){System.out.println("找到了，位置在"+i);isFlag=true}
}
if(isFlag){System.out.println("没有找到");
}

二分法查找：（注意二分法查找，所查找的数组必须是有序！！！）
int[] arr1=new int[] {1,2,3,4,5,6,7};int find1=2;int head=0;int end=arr1.length-1;int middle=0;boolean Flag=true;while(head<=end) {middle=(head+end)/2;if(find1==arr1[middle]) {System.out.println("找到了，位置在"+middle);Flag=false;break;}else if(find1>arr1[middle]) {head=middle+1;}else {end=middle-1;}}if(Flag) {System.out.println("没有找到");}

4、数组元素的排序算法

十大排序算法：
选择排序：
▷ 直接选择排序、堆排序
交换排序：
▷ 冒泡排序、快速排序
插入排序：
▷ 直接插入排序、折半插入排序、Shell排序
归并排序
桶式排序
基数排序

冒泡排序：

public class BubbleTest {public static void main(String[] args) {int[] arr = new int[] {10,30,20,40,70,60,50,80};for(int i=0;i<arr.length;i++) {for(int j=0;j<arr.length-i-1;j++) { if(arr[j]>arr[j+1]) {int temp=arr[j+1];arr[j+1]=arr[j];arr[j]=temp;}}}for(int i=0;i<arr.length;i++) {System.out.println(arr[i]);}    }
}

快速排序：（类似于二分法查找的排序方法，将数组对半分进行排序）

Arrays工具类的使用

1	boolean equals(int[] a,int[] b)	判断两个数组是否相等
2	String toString(int[] a)	输出数组信息
3	void fill(int[] a , int vel)	将指定值填充到数组之中
4	void sort(int[] a)	对数组进行排序
5	int binarySearch(int[] a,int key)	对排序后的数组进行二分法查找指定的值

     int[] arr1=new int[] {1,3,5,6,3,6};int[] arr2=new int[] {3,21,4,5,24,3};//boolean equals.(int[] a,int[] b) 判断两个数组是否相等 返回结果为布尔型boolean equal=Arrays.equals(arr1, arr2);System.out.println(equal);//String toString(int[] a)   输出数组信息System.out.println(Arrays.toString(arr1));//void fill(int[] a,int val) 将指定值val填充到数组中Arrays.fill(arr1,10);System.out.println(Arrays.toString(arr1));//void sort(int[] a) 对数组进行排序Arrays.sort(arr2);System.out.println(Arrays.toString(arr2));//int binarySearch(int[] a, int key)对排序后的数组进行二分法查找指定的值 //如果未找到指定的值，返回值为负数int index=Arrays.binarySearch(arr2, 4);System.out.println(index);

数组种常见的异常

1、数组角标越界的异常（ArrayIndexOutOfBoundsExcetion）

角标（索引）超出数组索引的范围导致的异常
int[] arr = new int[] {1,2,3,4,5,6};
System.out.println(arr[8]);

2、空指针异常（NullPointerException ）

由于数组为空导致的指针找不到地址，指针为空的异常
情况一
int[] arr = new int[] {1,2,3,4,5,6,7};
arr=null;//将数组定义为空，导致没有指针，出现异常
System.out.println(arr[1]);
情况二
int[][] arr = new int[3][];//外层数组中存储的内层数组的地址为空，导致指针为空异常System.out.println(arr[1]);//输出null 外层数组中存储的内层数组的地址为空System.out.println(arr[1][1]);//外层数组中存储的内层数组的地址为空，导致指针为空异常
情况三
int[] arr = new int[]{1,2,4,5,6};
arr[1]=null;
System.out.println(arr[1].toString());//由于指针找不到数组中的索引1的元素，指针为空，null调用方法会显示空指针异常

第四章、面向对象（上）

面向对象的含义

自学java核心技术笔记（康师傅）相关推荐

1. Java核心技术笔记 语言基础

   <Java核心技术 卷Ⅰ> 第3章 Java 的基本程序设计结构 一些规则 类命名:CamelCase 驼峰命名法,以及必须是字母开头,后面跟字母和数字的任意组合: 源代码文件名:必须与公 ...

2. Java核心技术笔记 异常、断言和日志

   <Java核心技术 卷Ⅰ> 第7章 异常.断言和日志 处理错误 捕获异常 使用异常机制的技巧 记录日志 处理错误 如果由于出现错误而是的某些操作没有完成,程序应该: 返回到一种安全状态,并 ...

3. 自学java基础笔记

   java基础教程 基础字符 public  公共的 class 类 static 静态的 void 无返回类型 main 主要的 String 字符串 args 参数 System 系统的 out 输 ...

4. 给大忙人看的Java核心技术笔记（8、Stream）

   流提供了数据视图,让你可以在比集合更高的概念层上指定操作.使用流只要指定做什么,而不是怎么做.将操作的调度执行留给实现. 要点: 1.迭代器使用了一种明确的遍历策略,同时也阻止了高效的并发执行 2.你 ...

5. Java核心技术笔记——第 12 章 反射

   转载自:[https://www.cnblogs.com/chanshuyi/p/head_first_of_reflection.html] 12 反射 1. 引入反射 通常情况下,调用一个类的方法 ...

6. Java核心技术笔记 1

   1.空串和null串 空串""s是长度为0的字符串,它是一个java对象,有自己的串长度和内容(空) 因此,可以调用String类对象的方法,如: if( str.length() ...

7. 自学Java系列 笔记2 高级类特性1

   关键字static(静态的) 在Java类中声明变量.方法和内部类时,可使用关键字static做为修饰符. static标记的变量或方法由整个类(所有实例)共享,如访问控制权限允许,可不必创建该类对象 ...

8. Java 核心技术卷 II(第 8 版) – 读书笔记 – 第 1 章（下）

   22.一旦获得了一个 Charset,就可以在 Java 的 Unicode 和指定的编码格式之间进行转化,下面以 GBK 和 Unicode 之间做为例子. 从 Unicode 到 GBK: imp ...

9. Java核心技术卷一读书笔记

   文章目录 Java核心技术卷一读书笔记 第一章 Java程序设计概述 1.1 关键特性 第二章 Java程序设计环境 2.1 使用命令行工具 第三章 Java的基本查询设计结构 3.1 数据类型 3. ...

最新文章

1. 2022-2028年中国气相防锈薄膜行业市场发展调研及投资前景分析报告
2. 安全事件日志中的登录事件
3. 畅谈Perl时间处理函数用法
4. 朴素贝叶斯分类器的python实现
5. 华为云FusionInsight助力宇宙行打造金融数据湖新标杆
6. SQL Server中SET赋值和SELECT赋值的区别
7. C++笔记(1)：使用STL中sort()对struct排序
8. Python模块：bisect二分算法模块
9. 软件oem要注意什么_软件开发需要注意什么
10. python字典里存字符_python基础知识（三）字典、字符串
11. 物联网嵌入式开发人员面临的5大挑战
12. 页面关键词密度 和布局 ，内页
13. java按键机nes模拟器_NES 模拟器开发教程 12 - 输入设备
14. java 公历 农历_java中怎么把公历日期转成农历日期
15. Flowable工作流之核心流程操作的本质
16. 使用pypcd读取pcd时ValueError: field ‘__0000‘ occurs more than once错误
17. Gradle Composite builds 扩展使用
18. HTTP/HTTPS与流量劫持/DNS劫持
19. 搜索引擎友好的HTML
20. c语言课程设计 水电费,广东工业大学水电费系统C语言设计(文件操作部分)

热门文章

1. 联想K3-Note固件编译，牛扎糖或更进一步？
2. 身份证号码正则表达式详解
3. 什么是物联网控制系统？它具有哪些特点？
4. php最快的学习路线
5. 笔记本电脑计算机出现问题怎么办,笔记本电脑经常死机怎么办 笔记本电脑死机原因分析...
6. HTML的简介、文档结构及基本标记
7. 长沙小学计算机老师,2019下半年湖南长沙小学信息技术教师资格证面试试题考什么内容...
8. 【新书速递】分布式事务开山之作，带你深入理解分布式事务
9. Moodle平台题库建设技术
10. 6_计算机网络_应用层-HTTP-DNS-跳板机