本文介绍了Java语言的基础知识，包括语言特点、技术架构、跨平台原理、JRE和JDK的使用，以及环境变量配置、类和接口命名规范、变量与方法、常量、进制转换、数据类型、运算符、函数、数组操作等核心概念。通过实例代码演示了如何编写、编译和运行简单的Java程序，如HelloWorld，以及九九乘法表的实现。此外，还提供了数组遍历、获取最大值和最小值、排序算法（选择排序和冒泡排序）以及参数传递的详细解释。
认识Java:
Java语言概述
Java语言是Sun公司在1995年正式发布的。
1、java语言特点：简单易懂、完全面向对象、安全可靠、与平台（OS）无关，“跨平台”语言。
2、java语言三种技术架构
javaSE---基础课程，javaEE和javaME---相当于两个不同方向的大学课程。
3、java语言的跨平台性(小霸王游戏机模拟器)。
--JVM
--java语言是跨平台的，但是JVM不是跨平台的。
4、跨平台原理
5、为什么要跨平台----在Windows系统上写java代码，但需要在Linux系统运行。
6、JRE和JDK：
--JRE ：JVM+java核心类库
--JDK ：JRE+java tools
7、JDK的下载
--官网
----ava.sun.com
--百度,谷歌
8、JDK的安装。
--注意问题：
----目录不要带有中文或者空格。
----JRE可以不必要单独安装。
9、常用软件介绍及安装
(1)JDK
(2)EditPlus
--如何把其添加至右键菜单
----工具--首选项--常规--选中最后一项
--如果去掉备份文件
----工具--首选项--文件--去掉保存时创建备份文件前面的对勾
(3)灵格斯翻译家
(4)截图软件
10、环境变量
(1)环境变量
--Path 指向灯 windows能够自动根据path去找你在控制台中输入的命令。exe。
(2)临时环境变量的配置
--set：用于查看本机的所有环境变量的信息。
--set 变量名 ：查看具体一个环境变量的值。
--set 变量名= ：清空一个环境变量的值。
--set 变量名=具体值 ：给指定变量定义具体值。
--%% 动态引用变量的值
(3)永久环境变量的配置
--找到环境变量
----我的电脑--右键属性--高级--环境变量--系统变量
--操作
----新建一个环境变量，格式如下
-----变量名 JAVA_HOME
-----变量值 JDK的安装目录。(D:\develop\Java\jdk1.6.0_30)
----编辑Path
-----变量名 Path
-----变量值 %JAVA_HOME%\bin;本身的环境变量值
11、体验一下HelloWorld
(1)开发工具
--记事本
--高级记事本 EditPlus
--IDE 集成开发环境
(2)体验HelloWorld
--编写源代码
class Demo
{
public static void main(String[] args)
{
System.out.println("HelloWorld");
}
}
----class是关键字，表示这是一个类。
----Demo 是类名，可以随便起，但是要符合标识符命名规则。
----jvm在执行过程中，要找main函数。
----类要独立运行时，必须有main函数。
-----格式：public static void main(String[] args)
--编译源代码
----javac命令用来编译源代码
-----格式 javac 源代码文件名
--运行字节码文件
----java命令用来运行java程序
-----格式 java 字节码文件的名字不带后缀名
12、classpath环境变量的配置
(1)path和classpath的区别
--path变量是windows程序文件的目录 (exe,bat。)
--classpath变量值是java类文件的目录 (class结尾)
(2)classpath如何配置
--临时配置
----set classpath=c:\my
--注意：
----设置了classpath，只在classpath下找。
----没有设置classpath，就在当前目录下找。
----如果classpath结尾设置了; 那么它将首先在classpath下找，
如果找不到，再在当前目录下找。但是不建议这样用。
*关键字：
1、被Java语言赋予了特殊含义的单词。
2、特点：关键字中所有字母都为小写。
3、goto和const虽然从未使用，但也作为 Java 关键字保留。
*标识符：
1、Java 语言中，对各种变量、方法和类等要命名时使用的字符序列称为标识符。
--简单记，就是起名字。
2、命名规则：
--由26个英文字母大小写，数字0-9，_，$等组成。
--不能以数字开头。
--不能与java的关键字重名。
3、命名规范：（见名知意，驼峰命名）
--包 所有单词小写
----看成是一个文件夹。
----www.itcast.cn cn.itcast.www cn/itcast/www
----www.baidu.com com.baidu.www
--类和接口
----如果是由一个单词组成，那么单词首字母大写。举例：Demo，Student。
-----如果是由多个单词组成，那么每个单词的首字母大写。举例：StudentDemo。
--变量与方法
----如果是由一个单词组成，那么单词首字母小写。举例：main，show。
----如果是由多个单词组成，第一个单词首字母小写，其后每个单词的 首字母大写。举例：showName。
--常量
----如果是一个单词组成，那么所有单词全部大写。举例：MAX。
----如果由多个单词组成，每个单词大写，并且以下划线相连接。举例：STUDENT_MAX_AGE。
*注释：
1、注解说明代码的，用于给人看的。
2、注释的分类
--单行注释 //
--多行注释 /*
注释内容
*/
--文档注释 /**
注释文档内容
*/
3、注释的用途
--注解说明文字。
--用于调试代码。
*常量：
1、定义：在程序的运行过程中，其值是不改变的量
2、常量的分类
A：整数常量 例如：1，2，10，150
B：小数常量 例如：1.0，2.3,13.14
C：布尔型常量(boolean) 例如：true,false
D：字符常量(char) 例如：'1','A',’b’/一个字符占两个字节
E：字符串常量(String) 例如："HelloWorld"
F：null常量
*变量：
1、定义：在程序的运行过程中，其值在指定范围内变化的值
2、是内存中一个区域，用于存储数据
3、变量的定义格式：
数据类型 变量名 = 初始化值;
4、变量在使用的时候
--第一种，在声明的时候，就初始化值
----数据类型 变量名 = 初始化值;
----举例：byte bys = 100;//System.out.println(bys);
--第二种 在使用前，赋值
----声明
----赋值
----使用
----举例 byte bys;
bys = 100; //System.out.println(bys);
进制（了解）
1、定义：就是进位制，是人们规定的一种进位方法。 对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位
2、java语言中整数的表现形式
--八进制
----逢八进一
----所能表示的数据有：0-7
----用0开头表示
--十进制
----逢十进一
----所能表示的数据有：0-9
--十六进制
----逢十六进一
----所能表示的数据有：0-9，A-F(10-15)
----用0x或者0X开头表示
3、进制的由来及特点。进制越大，表现形式越短
4、进制转换
--其他到十进制的转换
----其他进制包含二进制，八进制，十六进制
----转换规则
-----系数
-----基数
-----权
-----先把数据的每一位上的系数乘以对应基数的权次幂，然后相加
--十进制到其他进制的转换
----规则：除基取余，直到商为0，最后将余数反转
----十进制到二进制
-----除2取余，直到商为0，最后将余数反转
-----十进制13对应的二进制数据是1101
-----二进制到十进制的技巧(8421码)
----十进制到八进制
-----除8取余，直到商为0，最后将余数反转
-----十进制13对应的把进制数据是15
-----十进制--二进制--八进制
------首先把十进制转成二进制
------其次把二进制数据每三位组合。左边不够三位用0补位
------然后把每个组合计算成对应的十进制数据
------最后从左到右把数据相连接即可得到八进制
----十进制到十六进制
-----除16取余，直到商为0，最后将余数反转
-----十进制13对应的把进制数据是D
-----十进制--二进制--十六进制
------首先把十进制转成二进制
------其次把二进制数据每四位组合。左边不够四位用0补位
------然后把每个组合计算成对应的十进制数据
------最后从左到右把数据相连接即可得到十六进制
有符号数据的表示形式（了解）
1、原码
--所谓原码就是二进制数的有符号表示法，即最高位为符号位，"0"表示正，"1"表示负，其余位表示数值的大小
----举例
----- +7 0 0000111
----- -7 1 0000111
2、反码
--正数的反码和原码相同
----举例
----- +7 0 0000111
--负数的反码是符号位不变，数值为按位取反，就是0变1,1变0
----举例
----- -7 1 1111000
3、补码
--正数的补码和原码相同
----举例
----- +7 0 0000111
--负数的补码是符号位不变，数值为按位取反，就是0变1,1变0，最后在加1
----负数的补码其实就是反码加1
----举例
----- -7 1 1111001
*数据类型：
1、java语言分为两种数据类型
基本数据类型
引用数据类型(类,接口,数组)
2、基本数据类型
区别在内存中分配的空间大小不同，从而导致它表示的数据范围不同
4类8种：(byte short int long) (float double) (char) (boolean)
--整数
----byte 占1个字节
----short 占2个字节
----int 占4个字节
----long 占8个字节 其后加L或l标识
--浮点数
----float 占4个字节 其后加F或f标识
----double 占8个字节
--字符
----char 占2个字节
--布尔型
----boolean 占一个字节 ---- true,false
默认情况下：
*整数是int类型
*浮点数是double类型
3、数据参与运算
--整形，字符型，浮点型：数据在混合运算中相互转换时遵循以下原则
----容量小的类型默认转换为容量大的数据类型；数据类型按容量大小排序为：
-----byte,short,char->int->long->float->double
-----byte,short,char之间不会互相转换，他们三者在计算时首先会转换为int类型
----容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出；使用时要格外注意。
----有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后再进行计算。
--强制转换符(面试容易考)
----格式：(数据类型)(要被转换的数据) byte b = (byte)(130);
--字符型参与运算
----首先会去找对应字符的ASCII码值，然后运算。
--布尔型参与运算
----不能参与运算
--字符串参与运算
----它是和参与运算的数据相连接组成了一个新的字符串。
思考：
byte b1=3,b2=4,b;
b=b1+b2;//true：同等类型byte
b=3+4;//false：b是byte型，3、4是int型，
必须强转，改为：b=(int)（3+4）；
哪句是编译失败的呢？为什么呢？
*运算符
1、算术运算符 ：+,-,*,/,%,++,--
%：
--当左边小于右边：结果是左边
--当左边等于右边：结果是0
--当左边大于右边：结果是余数
--取余的正负号取决于左边
--用途：任意数%2 结果是要么0，要么1。用于切换条件
++,--：
--递增，递减运算符。就是加1或者减1
--单独存在，放在操作数的前面或者后面，结果一样
--参与运算时：
----放在操作数的前面，先自身加或者减1，然后再参与运算
----放在操作数的后面，先参与运算，然后再自身加或者减1
+：
--作为数据的符号
--做加法运算
--字符串连接符
2、赋值运算符：
=：赋值运算符 把右边的值赋给左边
-- 举例：int x = 3; 把3赋给int类型变量x
+=：加赋值运算符 把左边和右边的和赋给左边
-- 举例：int x = 3; x+=2;
-- +=运算符在给s赋值时，自动完成了强转操作。
3、比较运算符：==,!=,>,<,>=,<=
比较运算符的结果都是boolean型，也就是要么是true，要么是false。
4、逻辑运算符
逻辑与运算符：&
第一个条件 第二个条件 结果
true true true
false true false
true false false
false false false
简单记：同时为true，结果为true。
逻辑或运算符：|
第一个条件 第二个条件 结果
true true true
false true true
true false true
false false false
简单记：同时为false，结果为false。
逻辑异或运算符：^
第一个条件 第二个条件 结果
true true false
false true true
true false true
false false false
简单记：同时为同一种情况，结果为false。
逻辑非运算符：!
!true false
!false true
!!true true
短路与：面试容易考
&:左边无论什么结果，右边都执行。
&&:左边为false，右边不执行，结果为false。
短路或：面试容易考
|:左边无论什么结果，右边都执行。
||:左边为true，右边不执行，结果为true。
5、三元运算符
--(条件表达式)?表达式1：表达式2；
----如果条件为true，运算后的结果是表达式1；
----如果条件为false，运算后的结果是表达式2；
--条件运算符运算完之后一定有一个结果
*if语句：（判断结构）
1、if语句第一种格式
if(条件表达式)
{
执行语句；
}
A：无论条件表达式是简单还是复杂，结果是一个boolean类型的数据如果条件表达式结果不是boolean类型的，那么就报错。
B：当条件表达式的结果为true，就执行if所控制的语句；否则，就不执行
注意的问题：
C：大括号可以不写吗？
可以。但是是有条件的。如果if控制的只是单条语句，可以不加大括号。
如果if控制的是多条语句，那么必须加大括号。
建议：都加上大括号。
D：不要再if(条件表达式)加分号
2、if语句第二种格式
if(条件表达式)
{
执行语句1；
}
else
{
执行语句2；
}
A：比第一种多了else，否则，如果，那么的意思
B：如果条件表达式为true，执行语句1；否则，执行语句2
C：发现if语句和条件(三元)运算符有些相似。那么有没有区别呢？
具体可见下面代码体现！
3、if语句第三种格式
if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
A：最后一个else可以省略吗？
可以？但是一般建议写上。
*else是第三种if语句的组成部分，为了避免出现编译问题，建议加上
*我们不可能把所有的判断情况都想的特别清楚，所有建议加上
B：其实这个语句是一个整体，它是一条语句。当其中的某一种情况满足，那么执行语句并结束语句。
C：else后面有if的时候，一定要有条件表达式。单独else的时候，不能有条件表达式
D：什么情况下用哪种if语句
--if的第一种格式只做一种判断
--if的第二种格式只做二种判断
--if的第三种格式只做多种判断
4、if语句嵌套
if语句里面的执行语句是if语句。
5、if语句的应用场景
A：判断几个值的时候。
B：对结果是布尔类型的表达式进行判断的时候。
C：对范围进行判断。
*Switch语句：（选择结构）
自我理解：相当于在做选择题，被选答案用“case”标识。
格式：
switch(表达式)： //表达式类型：byte short int long
{
case 取值1: //实例情况
执行语句；
break; //如果执行了break，就马上离开switch
case 取值2:
执行语句；
break;
case 取值3:
执行语句；
break;
．．．．．．
default: //所有case都不匹配的情况下，执行default。
执行语句;
break;
}
执行情况：
备选答案没有指定的顺序，但是执行肯定是从第一个case开始，将每一个case都执行完；如果其中有匹配的case，执行完，通过该case的break就结束了switch；如果没有一个case匹配，执行default，程序结束。
Switch语句结束只有两种情况：
1、执行到了break；
2、执行到了default；
if和switch语句应用场景：
1、如果是对具体个数的数值进行判断：
用if可以，用switch也可以；建议使用switch，因为switch会将被选择的答 案加载进内存，选择效率高。
2、如果要对数据区间进行判断：用if语句。
3、如果运算结构是boolean类型：毫无疑问，用if语句。
循环语句（while，do while，for）
1、while语句格式：
while(条件表达式)
{
执行语句;
}
while特点：条件不满足，循环体不会执行。
2、do while语句格式：
do(做什么事)
{
执行语句;
}while(条件表达式)；
do while 特点：条件无论是否满足，循环至少执行一次。
while和 do while的区别：
while的循环体在下面，do while的循环体在上面。
**for循环：
语句格式：
for(初始化表达式A；循环条件表达式B；循环后的操作表达式D)
{
执行语句（循环体）C；
}
while和for区别：(面试容易考)
for为了循环而定义的变量在循环结束后在内存中释放；
while循环使用的变量在循环结束后还可以继续使用。
while和for的无限循环：
for( ; ; ){}
while(true){}
九九乘法表（for循环）
break和continue的区别：
break:应用范围----选择结构(switch)和循环结构，跳出应用范围没有任何价值；
continue:应用范围----循环结构，结束本次循环，继续下次循环；
continue单独存在时，下面不要定义语句，因为执行不到。
*函数：
1、函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
2、函数的格式
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…)
{
执行语句;
return 返回值;
}
A：修饰符：public static
B：返回值类型：函数运行后的结果的数据类型
C：函数名：为了方便使用这个函数，给它起个名字。这个名字要符合标识符命名规则。 main
D：参数类型 形式参数的数据类型
--形式参数(接收实参的变量)：是一个变量，用于存储调用函数时传递给函数的实际参数。接收方
--实际参数：传递给形参的具体数值，不可改变。发出方
E：执行语句 那么这个语句是由多条语句组成。
F：return 这个功能执行完以后，需要有一个返回值，那么这个值有关键字 return带回。
3、函数的特点
A：函数只有被调用后，才执行。
B：void 表示没有返回。在这个函数的结尾可以不写return。
--其实jvm会自动的结尾处加上return;
4、如果定义自己的函数 两个明确
A：明确该功能的结果 其实就是该功能的返回类型。
B：明确该功能的参数 其实就是明确该功能中是否需要未知内容(形式参数) 参与运算。
C：明确未知内容的类型和个数。
5、函数的重载
A：函数名相同，参数列表不同。
--参数类型不同。
--参数个数不同。
B：特点：与返回值类型无关，只看参数列表
C：好处：
--相同功能不同定义多个名称，一个名称即可。
--便于阅读，优化程序设计。
6、函数的基本思想：
不要把代码都写到主函数中，只要是功能，都用函数（方法）来体现，主函 数main()只用来调用已定义的功能，让该功能运行起来。
7、如何定义一个功能，只需2个明确即可：
----明确该功能的结果是什么？//明确java函数返回值类型
----明确该功能中是否需要未知内容参与运算？//明确java函数的参数(列表、 个数、类型)
*数组：
1、定义：同一种类型数据的集合。其实数组就是一个容器。
2、数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
3、数组的定义格式
A：当不明确数组中的元素时
---举例 int[] arr = new int[3];
B：当明确数组中的元素时
---举例 int[] arr = new int[]{1,2,3,4,5};
或者：int[] arr = {1,2,3,4,5};
4、什么时候使用数组？
--当要操作的数据是多个的时候，你就得想着先把这些数据用数组进行存储。
5、内存图
A：栈
---存储的是局部变量(在函数中定义的变量)。
----变量被使用完后，立即自动释放。
B：堆
---存储的是实体(数组和对象)。
----实体：new出来的东西，可以存放很多数据的东西。
-----class定义一个类。
----堆内存数据的特点
-----每个实体都有内存地址
-----堆内存中的变量都有默认初始化值
------int --> 0
------double --> 0.0
------boolean --> false
------char --> '\u0000' 空字符，unicode编码。
-----当实体不在被使用的时候，会在jvm空闲的时候，
通过java垃圾回收机制使其自动释放。
C：方法区
D：本地方法区：调用是Windows系统底层资源，我们也不用考虑。
E：寄存器：和CPU相关，我们不用考虑。
6、操作数组最常见的问题
A：当你访问到数组中的最后一个元素时，还想继续访问，这个时候，会 发生角标越界异常。
---ArrayIndexOutOfBoundsException
----举例 int[] arr = new int[3];
System.out.println(arr[3]);
B：当数组不在指向某个实体时，你还继续访问，就会发生空指针异常。
---NullPointerException
----举例 int[] arr = new int[3];
arr = null;
System.out.println(arr[1]);
7、常见的数组的操作
记住：对数组的操作，一定要从角标下手。
A：遍历操作
---数组的属性：length 数组的长度。
---格式：数组名.length
代码体现：
public static void printArray(int[] arr)
{
System.out.print("[");
for(int i=0; i<arr.length; i++)
{
if(i!=arr.length-1)
{
System.out.print(arr[i]+",");
}
else
{
System.out.print(arr[i]);
}
}
System.out.print("]");
}
B：获取最值
---获取最大值
代码体现：
public static int getMax(int[] arr)
{
int max = arr[0];
//i从1开始，因为第一个数不用跟自己比
for(int i=1; i<arr.length; i++)
{
if(arr[i]>max)
{
max = arr[i];
}
}
return max;
}
---获取最小值
public static int getMin(int[] arr)
{
int min = arr[0];
//i从1开始，因为第一个数不用跟自己比
for(int i=1; i<arr.length; i++)
{
if(arr[i]<min)
{
min = arr[i];
}
}
return min;
}
C：排序(非常重要的两个排序，熟练掌握！)
---选择排序
原理：如果拿0角标上的元素依次和后面的元素进行比较，
第一次内循环结束后，最小值出现在了0角标位置。
****
***
**
*
public static void selectSort(int[] arr)
{
//i<arr.length-1 n个数两两比，n-1次就能获得最值
for(int i=0; i<arr.length-1; i++)
{
//0角标元素没必要和自己比，所以j从1开始。
//发现j为了不重复比较，总是要比i大1，所以j从i+1开始
for(int j=i+1; j<arr.length; j++)
{
if(arr[j]<arr[i])
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
---冒泡排序
原理：两个相邻元素进行比较，第一次比较完以后，最大值出现在了最大角标处。
public static void bubbleSort(int[] arr)
{
//i<arr.length-1 n个数两两比，n-1次就能获得最值
for(int i=0; i<arr.length-1; i++)
{
//为了防止角标越界，j<arr.length-1
//为了减少比较次数，j<arr.length-1-i
for(int j=0; j<arr.length-1-i; j++)
{
if(arr[j]>arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
D：传递参数
---调用的时候，传递是基本类型的值的时候，形参改变对实参没有任何影响。
---调用的时候，传递是引用类型的地址值的时候，形参改变对实参有直接影响。
数组的操作：
1、查找
A：无序数组
public static int getIndex(int[] arr,int value)
{
for(int i=0; i<arr.length; i++)
{
if(arr[i]==value)
{
return i;
}
}
//当循环结束，说明元素在数组中不存在
return -1;
}
B：有序数组 二分查找
public static int getIndex(int[] arr,int value)
{
int min = 0;
int max = arr.length - 1;
int mid = (min+max)/2;
while(arr[mid]!=value)
{
if(arr[mid]>value)
{
max = mid - 1;
}
else if(arr[mid]<value)
{
min = mid + 1;
}
//如果没有怎么办？min max
if(min>max)
{
return -1;
}
mid = (min+max)/2;
}
return mid;
}
二维数组：
1、 int[][] arr = new int[3][2];
A：定义了名称为arr的二维数组
B：二维数组中有3个一维数组
C：每一个一维数组中有2个元素
D：一维数组的名称分别为arr[0], arr[1], arr[2]
arr:二维数组名
arr[1]:二维数组中的第二个数组名
arr[1][1]:二维数组中的第二个数组的第二个元素
E：给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
2、 格式2：int[][] arr = new int[3][];
A: 二维数组中有3个一维数组
B: 每个一维数组都是默认初始化值null
C: 可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
3、 int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
A：二维数组有3个一维数组。
B：第一个一维数组有3个元素
第一个一维数组有2个元素
第一个一维数组有4个元素
4、二维数组的遍历
public static void printArray2(int[][] arr2)
{
for(int i=0; i<arr2.length; i++)
{
for(int j=0; j<arr2[i].length; j++)
{
System.out.print(arr2[i][j]+" ");
}
System.out.println();
}
}
扫一扫
2348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
