java是 SUN(Stanford University Network，斯坦福大学网络公司)1995年推出的一门高级语言。
是一种面向 Internet的编程语言。
java语言的特点
1简介有效：java是一种相当简洁的面向对象的语言，省略了c++中容易混淆的特性，如指针，结构，单元等
2可移植性
3面向对象
4解释型
5适合分布式计算
6较好的性能:(1)java语言源程序编写完成后，先使用java伪编译器进行编译，将其转换为中间代码（也称为字节码）在解释(2)提供了一种“准时时”编译器，当需要更快的速度的时候，可以使用just-in-time(JIT)编译器将字节码转换成机器码，然后将其缓冲下来，这样速度就更快
7健壮性
8多线程处理能力
9较高的安全性
10是一种动态语言
java程序的运行机制
计算机高级语言类型主要有编译型和解释型两种，java是2种类型的集合，在java中代码的处理过程如下。
在java中，源文件名称的后缀为.java，之后通过编译使*.java的文件生成一个*.class文件，在计算机上执行*.class文件，但是此时执行*.class的计算机并不是一个物理上可以看到的计算机，而是java自己设计的一个计算机---JVM，java是通过JVM进行可移植性操作的
java虚拟机----Java Virtual Machine（简称JVM）
它是运行所有 Java程序的抽象计算机,是 Java语言的运行环境，JVM读取并处理编译过的与平台无关的字节码(class)文件。
Java 编译器针对 JVM产生 class文件，因此是独立于平台的。
Java 解释器负责将 JVM的代码在特定的平台上运行。
Java 虚拟机是不跨平台的.
javac命令的作用
javac.exe是java本身提供的编译命令，主要目的是用来将*.java文件编译成*.class文件，此命令本身不属于windows系统，所以在使用时需要单独配置
classpath属性的作用
classpath主要指的是类的运行路径。在执行java命令时，对于本地的操作系统来说就意味着启动了一个JVM，那么JVM在运行时需要通过classpath加载所需要的类，而默认情况下classpath是指向当前目录（当前命令行窗口所在的目录）
java程序的注释
注释：单行//，多行/* */，文档注释/** */
1.单行注释 //:
2.多行注释 /* */:
3.文档注释 /** */:
java中的标识符
java中的包，类，方法，参数和变量的名字可以由任意的大小写字母，数字，下划线(_)和美元符号($)组成，但是标识符不能以数字开头，也不能使用java的保留关键字
变量和常量
变量时利用声明的方式将内存中的内存块保留下来以供程序使用。可以声明数据类型为整型，字符，浮点或者是其他数据类型，作为变量的保存值用.
数据类型划分
java的数据类型可分为基本数据类型和引用数据类型。原始数据类型也称为基本数据类型，包括boolean,byte,char,short,int,long float与double。另一种数据类型为引用数据类型。
|
|
数据类型 大小/位 可表示范围
long（长整形） 64位
int（整数） 32位
short（短整数） 16位
byte（位） 8位 -128-127
char（字符） 2位 0-255
float（单精度） 32位
double（双精度） 64位
整数类型
当数据不带小数或者分数时，可以声明为整数变量。在java中，整数数据类型可以分为long，int，short和byte。
字符类型
字符类型在内存中占有2个字节，可以用来保存英文字母等字符。计算机处理字符时，是把这些字符当成不同的整数来看待，严格来说，字符类型也算是整数类型。
PS：字符型常量也可以采用16进制编码方式表示，范围是'\u0000'-'\uFFFF',一共可以表示65535个字符，其中前256个字符和ASCII码中的字符完全重合
不仅如此，char类型的值也可直接作为整数型的值来使用，但它是一个16位无符号整数，即全部是整数，范围是0-65535.如果把一个在0-65535内的int整数赋值给char类型的变量，系统会自动把这个int整数当成char来处理
实例代码----字符和数字之间的转化
public class Demo{
public static void main(String args[]){
char ch1 = 'a' ; //字符是使用”'“括起来的数据
char ch2 = 97; //通过数字定义字符变量
System. out.println("ch1 = " + ch1) ;
System. out.println("ch2 = " + ch2) ;
}
};
结果：ch1 = a
ch2 = a
浮点数类型和双精度浮点数类型
在日常生活经常会使用到小数类型的数值，如身高，体重等，整数将不能满足程序的要求，在数学中，这些带有小数点的数值称为实数。在java中，这种数据类型称为浮点数类型(float).
需要注意的是，使用浮点型数值时，默认的类型是double，在数值后面加上D或者是d，作为double类型的标识。在java中，D或d是可有可无的。在数据后面加上f或者F，则作为float类型的识别。弱没有加上，java就会将该数据默认为double类型
实例代码
public class Demo{
public static void main(String args[]){
float num = 3.0f ; //定义一个浮点型变量
System. out.println("两个小数相乘：" + num * num) ;
}
};
结果：两个小数相乘：9.0
布尔类型
boolean类型那个的变量只有true和false两种。当将一个变量定义成布尔类型时，它的值只能是true或者false，除此之外，没有其他的值可以赋给这个变量
实例代码
public class Demo{
public static void main(String args[]){
boolean flag = true ; //定义布尔型变量
System. out.println("flag = " + flag) ; //打印输出
}
};
结果：flag = true
数据类型的转换
java的数据类型在定义时已经确定了，因此不能随意转换成其他类型的数据类型，但java允许用户有限度的做类型转换处理。
java会在下列条件都成立时，自动做数据转换类型
1 转换前的数据类型与转换后的类型兼容
2 转换后的数据类型的表示范围比转换前的类型大
实例代码
public class Demo{
public static void main(String args[]){
int x = 30; //定义整型变量
float y = 22.19f; //定义浮点型变量
System. out.println("x / y = " + (x / y)) ;
System. out.println("10 / 3.5 = " + (10 / 3.5)) ;
System. out.println("10 / 3 = " + (10 / 3)) ;
}
};
结果：x / y = 1.3519603
10 / 3.5 = 2.857142857142857
10 / 3 = 3
PS:如果2个int类型的常量进行计算，最终结果还是int类型，而其小数部分将会被忽略.
PS：任何类型的数据碰到String类型的变量或者常量之后都会向String类型转换
运算符，表达式与语句
赋值运算符
赋值运算符号（=）
实例代码
public class Demo{
public static void main(String args[]){
int num = 22 ;
System. out.println("第一次输出：num = " + num) ;
num= num - 3 ; // 修改变量内容，java会先处理等号后面num-3的部分，再赋值给等号前面的变量num
System. out.println("第二次输出：num = " + num) ;
}
};
结果：第一次输出：num = 22
第二次输出：num = 19
一元运算符
+ 正号
- 负号
！ NOT，否
实例代码
public class Demo{
public static void main(String args[]){
boolean b = false ;
int x = 10 ;
int y = -30 ;
System. out.println("b = " + b + "， !b = " + !b) ; //取反
System. out.println("x = " + x + "， -x = " + -x) ; //使用符号
System. out.println("y = " + y + "， +y = " + +y) ; //使用正号
}
};
结果：
b = false， !b = true
x = 10， -x = -10
y = -30， +y = -30
算数运算符
算数运算符在数学中经常用到
+ 加法
- 减法
* 乘法
/ 除法
% 取模（取余数）
实例代码
public class Demo{
public static void main(String args[]){
int i = 10 ;
int j = 3;
System. out.println(i + " + " + j + " = " + (i+j)) ; //加法操作
System. out.println(i + " - " + j + " = " + (i-j)) ; //减法操作
System. out.println(i + " * " + j + " = " + (i*j)) ; //乘法操作
System. out.println(i + " / " + j + " = " + (i/j)) ; //加法操作
System. out.println(i + " % " + j + " = " + (i%j)) ; //取模操作
}
};
结果：10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3 如果2个int类型的常量进行计算，最终结果还是int类型，而其小数部分将会被忽略.
10 % 3 = 1
关系运算符
> 大于
< 小于
>= 大于等于
<= 小于等于
!= 不等于
== 等于
实例代码
public class Demo{
public static void main(String args[]){
System. out.println("3 > 1 = " + (3 > 1)) ; //使用大于号
System. out.println("3 < 1 = " + (3 < 1)) ; //使用小于号
System. out.println("3 >= 1 = " + (3 >= 1)) ; //使用大于等于号
System. out.println("3 <= 1 = " + (3 <= 1)) ; //使用小于等于号
System. out.println("3 == 1 = " + (3 == 1)) ; //使用等于号
System. out.println("3 != 1 = " + (3 != 1)) ; //使用不等于号
}
};
结果：3 > 1 = true
3 < 1 = false
3 >= 1 = true
3 <= 1 = false
3 == 1 = false
3 != 1 = true
自增与自减运算符
自增与自减运算符也是各个语言最常见的运算符，因为它们具有相当大的便利性
a=a++//a加1后再赋值给a存放
++a//直接给a加1
实例代码
public class Demo{
public static void main(String args[]){
int a = 3 , b = 3 ; //定义两个变量a和b
int x = 6, y = 6 ; //定义两个变量x和y
System. out.println("a = " + a) ;
System. out.println("\t a++ = " + (a++) + "， a = " + a) ; //先计算后自增
System. out.println("b = " + b) ;
System. out.println("\t ++b = " + (++b) + "， b = " + b) ; //先自增后计算
System. out.println("x = " + x) ;
System. out.println("\t x-- = " + (x--) + "， x = " + x) ; //先计算后自减
System. out.println("y = " + y) ;
System. out.println("\t --y = " + (--y) + "， y = " + y) ; //先自减后计算
}
};
结果：
a = 3
a++ = 3 ， a = 4
b = 3
++b = 4 ， b = 4
x = 6
x-- = 6 ， x = 5
y = 6
--y = 5 ， y = 5
逻辑运算符
&--------and，与
&&-------短路与
|--------or，或
||-------短路或
当使用逻辑运算符&&时，运算符前后的两个操作数的返回值都为真，运算的结果才会为真；使用逻辑运算符||时，运算符前后的两个操作数的返回值只要有一个为真，运算的结果就为真。
public class Demo{
public static void main(String args[]){
boolean a = true ;
boolean b = false ;
System. out.println("a || b = " + (a || b)) ;
System. out.println("a | b = " + (a | b)) ;
System. out.println("a && b = " + (a && b)) ;
System. out.println("a & b = " + (a & b)) ;
}
};
结果：
a || b = true
a | b = true
a && b = false
a & b = false
问题：为什么会有两种与和或操作？
与分为短路与和非短路与，或分为短路或和非短路或。
1 对于与（&&，&）来说，如果第一个条件结果为假，则后面条件不管真假，最终的结果都为假
2 对于或（||，|）来说，如果第一个条件结果为真，则后面条件不管真假，最终的结果都为真
那么也就是对于与和或来会说，第一个条件就是一个关键性的条件，在java中设置了短路与和短路或
3 对于与（&&，&）来说，要求所有的条件都判断，而如果使用了短路与（&&），第一个条件又为false，则后面的条件将不再判断
4对于或（||，|）来说，要求所有的条件都判断，而如果使用了短路与（||），第一个条件又为true，则后面的条件将不再判断
验证'&'(与)的作用
public class Demo{
public static void main(String args[]){
if(10!=10&10/0==0) {//因为&会把2个条件都验证一次
System. out.println("条件满足") ;
}
}
};
结果：程序报错java.lang.ArithmeticException: / by zero
验证'&&'(短路与)的作用
public class Demo{
public static void main(String args[]){
if (10!=10&&10/0==0) {//使用了短路与（&&），第一个条件又为false，则后面的条件将不再判断
System. out .println( "条件满足") ;
}
}
};
结果：无输出，不报错
验证'|'(或)的作用
public class Demo{
public static void main(String args[]){
if (10==10|10/0==0) {//因为|会把2个条件都验证一次
System. out .println( "条件满足") ;
}
}
};
结果：程序报错java.lang.ArithmeticException: / by zero
验证'||'(短路或)的作用
public class Demo{
public static void main(String args[]){
if (10==10||10/0==0) {//使用了短路或（||），第一个条件又为true，则后面的条件将不再判断
System. out .println( "条件满足") ;
}
}
};
结果：条件满足
位运算符
位运算符操作就是指进行二进制的运算
&---------按位与
|---------按位或
^---------异或（相同为0，不同为1）
~---------取反
<<--------左移位
>>--------右移位
>>>-------无符号移位
在java中所有的数据都是以而进制数据的形式进行运算的，即如果一个int型变量，要采用位运算时必须将其变为二进制数据。每一位二进制进行与，或，异或操作的结果如下
二进制数1---二进制数1---与操作(&)---或操作(|)---异或操作(^)
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0
选择与循环语句
程序的结构有顺序结构，选择结果和循环结构三种。
顺序结构代码实例
public class Demo{
public static void main(String args[]){
System. out.println("顺序结构1" ) ;//依次打印信息
System. out.println("顺序结构2" ) ;//依次打印信息
System. out.println("顺序结构3" ) ;//依次打印信息
}
}
结果:顺序结构1
顺序结构2
顺序结构3
选择结构
选择结构是根据条件的成立与否决定要执行哪些语句的一种结构。这种结构可以依据判断条件的结构来决定要执行的语句。当判断条件为真时，就执行语句1；当判断条件为假，就执行语句2.
选择结构结构包括if,if...else,和switch语句，语句中加了选择结构之后，就像是十字路口，根据不同的选择，程序会有不同的结果
if语句
根据判断的结构来执行不同的语句时，使用if语句就是一个很好的选择，它会准确的检测判断条件是否成立，再决定是否要执行后面的语句
格式：
if(判断条件){
语句1；
语句2；
}
实例代码
public class Demo{
public static void main(String args[]){
int x = 3; //定义整型变量3
int y = 10 ; //定义整型变量10
System. out .println("=====比较开始 =====") ;
if (x>y){
System. out .println("x比y大！" );
}
if (x<y){
System. out .println("x比y小！" ) ;
}
System. out .println("=====比较完成 =======") ;
}
}
结果：=====比较开始 =====
x比y小！
===== 比较完成 =======
if...else语句
当曾旭中存在含有分支的判断语句时，就可以使用if...else语句处理。当判断条件成立时，执行if语句主体；判断条件不成立时，执行else后面的语句主体。
语句格式
if(判断主体){
语句主体1；
}else{
语句主体2；
}
实例代码
public class Demo{
public static void main(String args[]){
int x = 3; //定义整型变量x
if(x%2==1){ //判断于是是否为1
System. out.println("x是奇数！" ) ; // 如果余数为1表示奇数
} else{
System. out.println("x是偶数！" ) ; // 如果余数为0表示是偶数
}
}
}
结果：x是奇数！
三目运算符
有一种运算符可以代替if...else语句，就是三目运算符
变量 =判断条件?表达式1：表达式2，当条件成立时，就执行表达式1，否则执行表达式2
代码实例：使用三目运算符求2个数字中的最大值
public class Demo{
public static void main(String args[]){
int max = 0 ; //保存最大值
int x = 3; //定义整型变量x
int y = 10 ;
max= x>y?x:y ; //通过三目运算符求出最大值
System. out.println("最大值为：" + max) ;
}
}
结果：最大值为：10
switch语句
switch语句可以将多选一的情况简化，使程序更加简洁.
语句格式
switch(表达式){
case 选择值1: 语句主体1
break;
case 选择值2：语句主体2
break;
default:语句主体
}
switch流程
1先计算括号内表达式的结果(数字，字符，枚举)
2根据表达式的值检测是否符合case后面的选择值。若是所有值都不符合，则执行default语句，执行完毕立即离开switch语句
3如果某个case的选择值符合要求，则执行该case的语句，一直到break语句后才离开swtich语句
4若是没有在case后加上break语句，则会一直执行到switch的尾端才离开
代码实例
public class Demo{
public static void main(String args[]){
int x = 3 ;
int y = 6 ;
char op = '+' ;
switch(op){
case '+' :{ //执行加法操作
System. out.println("x + y = " + (x + y )) ;
break ;
}
case '-' :{ //执行减法操作
System. out.println("x - y = " + (x - y )) ;
break ;
}
default:{
System. out.println("未知的操作！" ) ;
break ;
}
}
}
}
结果：x + y = 9
循环结构
while是循环语句，也是条件判断语句。当事先不知道循环多少次该执行时，就要用到while
语句格式
while(循环条件判断){
语句1；
语句2；
循环条件更改；
}
实例代码
public class Demo{
public static void main(String args[]){
int x = 1;
int sum = 0 ; //保存累加的结果
while(x<=10){
sum+= x ; //进行累加操作
x++; //修改循环条件
}
System. out.println("1 --> 10累加的结果为：" + sum) ;
}
}
结果：1 --> 10累加的结果为：55
do....while循环
do....while循环是每次都是先执行一次循环主体，然后再测试判断条件的真假。无论循环成立的条件是什么，使用do....while循环时，至少都会执行一次循环主体
语句格式
do{
语句1
语句2
循环条件改变
}while（循环条件改变）
实例代码
public class Demo {
public static void main(String args[]) {
int x = 1;
int sum = 0;
do {
sum+= x;
x++;
} while (x <= 10);
System. out.println("1 --> 10累加的结果为：" + sum);
}
}
结果：1 --> 10累加的结果为：55
for循环
知道循环次数的情况下，就可以使用另外一种循环语句--for循环。
语句格式
for（赋值初值；判断条件；赋值增减量）{
语句1；
语句n；
}
代码实例
public class Demo {
public static void main(String args[]) {
int sum = 0;
for (int i =0; i <= 10; i ++) {
sum+= i;
}
System. out.println("1 --> 10累加的结果为：" + sum);
}
}
结果：1 --> 10累加的结果为：55
循环的中断
break语句可以强迫程序中断循环，当程序执行到break语句时，即会离开循环，继续执行循环外的下一个语句。如果break语句出现在嵌套循环中的内层语句，则break会跳出当前层的循环
实例代码
public class Demo {
public static void main(String args[]) {
for(int i=0;i<10;i++){//使用for循环
if(i==3){//如果i的值为3，则退出整个循环
break ;//退出循环
}
System. out.println("i = " + i) ;//打印信息
}
}
}
countinue语句
continue语句可以强迫程序跳到循环的起始处，当程序运行到continue语句时，会停止运行剩余的循环体而是回到循环开始处继续运行。
所以continue只是中断了一次循环
实例代码
public class Demo {
public static void main(String args[]) {
for(int i=0;i<5;i++){//使用for循环
if(i==3){//如果i的值为3
continue ;//退出一次循环
}
System. out.println("i = " + i) ;//打印信息
}
}
}
结果：i = 0
i = 1
i = 2
i = 4
java基础学习小结
1 java的数据类型分为基本数据类型和引用数据类型
2 Unicode为每个字符制订了一个唯一的数值，在任何的语言，平台程序都可以放心的使用
3 boolean类型的变量只有true和false两个值
4 算数运算符的成员有加法，减法，乘法，除法和余数运算符
5 if语句可依据判断的结果来决定程序的流程
6 自增与自减运算符有相当大的便利性，利用他们可提高程序的简洁程度
7 当表达式中有类型不匹配时，有下列的处理方法
1占用较少字节的数据类型会转换成占用较多字节的数据类型
2有short和int类型时，则用int类型
3字符类型会转换成short类型
4若一个操作数的类型为double，则其他的操作数也会转换成double类型
8 break语句可以强迫程序中断循环，当程序遇到break语句时，即会离开循环，继续执行到循环外的下一个语句。如果break语句出现在嵌套循环中的内层循环，则break语句只会跳出当前层的循环
9 continue语句可以强迫程序跳到循环的起始处，当程序运行到continue语句时，会停止运行剩余的循环体而是回到循环开始处继续运行。
所以continue只是中断了一次循环
3641
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
