java 基础（一）

2，初识java

java诞生

在Java诞生之前已经出现了许多优秀的编程语言，如大家所熟悉的C语言和C++语言等，那么是什么原因导致了Java的诞生呢？Java语言相对于其他语言来说到底又有着怎样的特殊优势呢？
Java语言相对于其他语言的最大优势就是所谓的平台无关性，即跨平台性，这也是Java最初风靡全球的主要原因。
无论哪种变编程语言编写的应用程序都需要经过操作系统和处理器来完成程序的运行，因此这里所指的平台是由操作系统（OS）和处理器（CPU）所构成。与平台无关是指软件的运行不因操作系统、处理器的变化导致发生无法运行或者出现运行错误。
平台最终识别并且执行的是一种由0和1组成的序列代码，我们称之为机器指令。相同的CPU和不同的操作系统所形成的平台的机器指令可能也是不同的，因此，每种平台都会形成自己独特的机器指令。例如，某个平台可能用8位序列代码10001111表示一次加法操作，以10100000表示一次减法操作，而另外一个平台可能用8位序列代码10101010表示一次加法操作，以10010011表示一次减法操作。

C/C++运行过程

Java语言运行过程

Java语言和其他语言相比，最大的优势就是它的平台无关性，这是因为Java可以在平台之上再提供一个Java运行环境，该Java运行环境由Java虚拟机（JVM）、类库以及一些核心文件组成。Java虚拟机的核心是所谓的字节码指令，即可以被Java虚拟机直接识别、执行的一种由0和1组成的序列代码。字节码并不是机器指令，因为它不和特定的平台相关，不能被任何平台直接识别和执行。Java针对不同平台提供的Java虚拟机的字节码指令都是相同的，如所有的虚拟机都将11110000识别、执行为加法操作。

JDK和环境变量配置

1、下载并且安装JDK
2、配置系统环境变量

3，hellowrold

1、应用程序的主类
一个Java应用程序可以由若干个Java源文件所构成，每个源文件又可以由若个书写形式互相独立的类组成，但其中一个源文件必须有一个类含有public static void main(String args[])方法，这个类称之为这个应用程序的主类。args[]是main方法的一个参数，是一个字符串类型的数组。所有的Java应用程序都是从主类的main开始执行。
2、源文件的命名
源文件的名字与类的名字相同，扩展名是.java。注意大小写，因为Java语言是区分大小写的。同时Java有着一些命名规范，但是并不会强制要求你必须这样去写：
a.包的命名：全部小写（com.blue）
b.类的命名：单词首字母大写（Hello）
c.方法的命名：首字母小写，后面的单词首字母大写（getName）
d.常量的命名：全部大写，常加入下划线（MAX_VALUE）

新建Hello.java文件

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

运行结果：

C:\Users\Administrator\Desktop\javaDemo\03>java Hello
hello world

简单

如果同学们学过C++语言，就会感觉Java眼熟，因为Java中许多基本语句的语法和C++是一样的，像常用的循环语句、控制语句等和C++几乎相同。需要注意的是，Java和C++时两种完全不同的语言，各有各的优势，将会长期并存下去。如果从语言的简单性方面来看，Java要逼C++简单，C++中许多容易混淆的感念，或者被Java弃之不用了，或者以一种更清楚更容易理解的方法实现，例如Java中不再有指针的概念。

面向对象

基于对象的编程更加符合人的思维模式，使人们更容易解决复杂的问题，Java就是一种面向对象的编程语言。

多线程

Java的特点之一就是内置对多线程的支持。多线程允许同时完成多个任务。实际上多线程使人产生多个任务在同时执行的错觉，因为目前的计算机的处理器在同一时刻只能执行一个线程，但处理器可以在不同的线程之间快速的切换，由于处理器的速度非常快，远远超过了人接收信息的速度，所以给人的感觉好像是多个线程在同时执行。C++没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序的设计。

安全

当准备从网络上下载一个程序时，最大的担心是程序中含有恶意的代码，会试图读取或者删除本地计算机上的一些重要文件。当使用支持Java的浏览器时，可以放心的运行Java Applet程序，不必担心病毒的感染。Java Applet程序由浏览器内置的Java运行环境负责解释执行，浏览器内置的Java运行环境不允许Java Applet程序访问当前浏览器上下文环境以外的其他部分。

动态

在通过了后面的学习之后，同学们就会发现Java程序的基本组成单元就是类，有些类是自己编写的，有些是从类库中引入的，而类又是运行时动态装载的，这就使得Java可以在分布式环境中动态的维护程序以及类库。而C/C++编译时就将函数库或者类库中被使用的函数、类同时生成机器码，那么每当类库升级以后，如果想要具有类库提供的新功能，程序就必须重新修改和编译。

4，标识符和关键字

标识符

用来标识类名、变量名、方法名、类型名、数组名、文件名等等的有效字符序列称之为标识符。简单的说，标识符就是一个名字。以下是Java关于标识符的语法规则：
1、标识符由字母、下划线、美元符号和数字组成，长度不受限制。
2、标识符的第一个字符不能是数字字符。
3、标识符不能是关键字。
4、标识符不能是true、false和null（尽管true、false和null不是Java的关键字）
例如：Hello_java、Hello_12$、$23Boy
需要特别注意的是，标识符中的字母是区分大小写的，hello和Hello是不同的标识符。
Java语言使用Unicode标准字符集，Unicode字符集由UNICODE协会管理并接受其技术上的修改，最多可以识别65563个字符，Unicode字符集的前128个字符刚好是ASCII码表。Unicode字符集还不能覆盖全部历史上的文字，但大部分国家的“字母表”的字母都是Unicode字符集中的一个字符，如汉字中的“你”字就是Unicode字符集中的第20320个字符。Java所谓的字母包括了世界上大部分语言中的“字母表”，因此Java所使用的字母不仅包括通常的拉丁字母a，b，c等，也包括汉语中的汉字、日文的片假名和平假名、朝鲜文、俄文、希腊字母以及其他许多语言中的文字。

标识符使用规范：

• 类名首字母大写，
• 表示方法和变量的标识符：首字母小字，从第二个单词开始，首字母大写。称为“驼峰原则”，如eat(),eatFook()。

/**
 * 
 * @author 荆盼
 *
 */
public class TestIdentifer {

	public static void main(String[] args) {
		int a123 = 1;
		//int 123abc = 2; //数字不能开头
		int $a = 3;
		int abc = 4;
		//int #abc = 5;
		
		int 年龄 = 10; //可以使用汉字，但不一般不建议
		
		//int class = 2; //关键字不能作为标识符

	}

}

关键字

关键字就是Java语言中已经被赋予了特定意义的一些单词。不可以把关键字作为标识符来用，以下就是Java的关键字：
访问控制
private 私有的   protected 受保护的   public 公共的
类、方法和变量修饰符：
abstract 声明抽象     class 类          extends 扩允,继承 final 终极,不可改变的    implements 实现
interface 接口          native 本地     new 创建              static 静态                   strictfp 严格,精准
synchronized 线程,同步                 transient 短暂       volatile 易失
程序控制语句：
break 跳出循环     continue 继续       return 返回    do 运行      while 循环     if 如果
else 反之               for 循环                instanceof 实例               switch 开关
case 返回开关里的结果                      default 默认
错误处理：
try 捕获异常      catch 处理异常      finally 有没有异常都执行      throw 抛出一个异常对象
throws 声明一个异常可能被抛出     assert 断言
包相关：
import 引入       package 包
基本类型：
boolean 布尔型     byte 字节型       char 字符型       double 双精度       float 浮点
int 整型                long 长整型       short 短整型      null 空                  true 真
false 假                 enum 枚举
变量引用：
super 父类,超类     this 本类    void 无返回值
关键字(51)+保留字(const,goto)共53个 

4.1 变量的本质

变量本质上就是代表一个"可操作的存储空间"，空间位置是确定的，但是里面放置什么值不确定。我们可通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值。

Java是一种强类型的语言，每个变量都必须声明其数据类型。

/**
 *测试变量
 * @author 荆盼
 *
 */
public class TestVarialbe {

	public static void main(String[] args) {
		int age;
		age = 18;
		int salary = 3000;
		
		//变量必须初始化才可以使用
		int gao =13;
		System.out.println(gao);
	}

}

4.2 变量分类

局部变量，成员变量，静态变量。

/**
 *测试变量
 * @author 荆盼
 *
 */
public class TestVarialbe {
	int a; //成员变量（也叫实例变量，member variable） 
	
	/*静态变量（类变量 static variable）使用static定义。从属于类，生命周期
	 *伴随类始终，从类加载到卸载*/
	static int  size; 

	public static void main(String[] args) {
		int age;
		age = 18;
		int salary = 3000; //局部变量，从属于方法。
		
		//变量必须初始化才可以使用
		int gao =13;
		System.out.println(gao);
	}
}

5，基本数据类型

java语言一共有8种基本数据类型，分别是：

8种 boolean,byte,short int,long,float,double,char.

这8种基本数据类型在习惯上可以分为以下四大类型：

逻辑类型：boolean

整数类型:byte,short,int ling

字符类型:char

浮点类型:float、double

逻辑类型：

常量：true,false

变量：使用关键字boolean来声明变量，声明时也可以赋给初值。

例如：boolean x,ok=true,关闭=false;

 

 

整数类型

1．int 型
常量：123，6000（十进制），077（八进制），0x3ABC（十六进制）。
变量：使用关键字int来声明int型变量，声明时也可以赋给初值，
例如：int x= 12,平均=9898,jiafei;
对于int型变量，内存分配给4个字节（byte），占32位。
2．byte型
常量：Java中不存在byte型常量的表示法，但可以把一定范围内的int型常量赋值给byte型变量。 
变量：使用关键字byte来声明byte 型变量
例如：byte x= -12,tom=28,漂亮9;
对于byte型内存分配给1个字节，占8位。
3 ．short 型
常量：和byte型类似，Java中也不存在short型常量的表示法，但可以把一定范围内的int型常量赋值给short型变量。
变量：使用关键字short来声明short型变量
例如：short x=12,y=1234;
对于short型变量，内存分配给2个字节，占16位。
4. long 型
常量：long型常量用后缀L来表示，例如108L（十进制），07123L（八进制）、0x3ABCL(十六进制) 。
变量：使用关键字long来声明long型变量，
例如：long width=12L,height=2005L,length;
对于long型变量，内存分配给8个字节，占64位。

/**
 * 测试基本数据类型
 * @author 荆盼
 *
 */
public class TestPrimitiveDataType {
	public static void main(String[] args) {
		//测试整形变量
		int a = 15;
		int b = 015;//以0开头的是八进制
		int c = 0X15;//十六进制
		int d = 0b1101;//二进制
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		
		
		byte age = 30;
		short salary = 30000;
		int population = 2000000000;//整形常量默认是int类型
		long globalPopulation = 7400000000l;//后面加L表示这是一个long类型的常量
	}
}

字符类型

1. 常量：‘A’，‘b’，‘?’，‘!’，‘9’，‘好’，‘\t’，‘き’，‘モ’等，即用单引号扩起的Unicode表中的一个字符。 
2. 变量：使用关键字char来声明char型变量，
例如：char ch=‘A’,home=‘家’,handsome=‘酷’;
对于char型变量，内存分配给2个字节，占16位。 
3. 转意字符常量:有些字符（如回车符）不能通过键盘输入到字符串或程序中，就需要使用转意字符常量，
例如：\n（换行），\b（退格），\t（水平制表）， \‘（单引号），\“（双引号），\（反斜线）等。
4. 要观察一个字符在Unicode表中的顺序位置，可以使用int型显示转换，如(int)'a'或int p='a'。
5. 如果要得到一个0~65536之间的数所代表的Unicode表中相应位置上的字符必须使用char型显示转换。

/**
 * 测试字符类型
 * @荆盼
 *
 */
public class TestPrimitiveDataType3 {

	public static void main(String[] args) {
		char a = 'T';
		char b = '上';
		char c = '\u0061';
		System.out.println(c);
		//转义字符
		System.out.println('a' + 'b');//195
		System.out.println(""+ 'a' + 'b');//ab
		System.out.println(""+ 'a' + '\n' +'b');/*a
												  b*/
		
		System.out.println(""+ 'a' + '\t' +'b');//a	b
		
		System.out.println(""+ 'a' + '\'' +'b');//a'b
		
		//String就是字符序列
		String d = "abc";
	}
}

浮点类型

1. float型
常量：453.5439f，21379.987F，231.0f（小数表示法），2e40f（2乘10的40次方，指数表示法）。需要特别注意的是：常量后面必须要有后缀“f”或“F”。  
变量：使用关键字float来声明float型变量，
例如：float x=22.76f,tom=1234.987f,weight=1e-12F;
精度:float变量在存储float型数据时保留8位有效数字，实际精度取决于具体数值。 
对于float型变量，内存分配给4个字节，占32位。
 2. double 型
常量：2389.539d，2318908.987，0.05（小数表示法），1e-90（1乘10的-90次方，指数表示法）。对于double常量，后面可以有后缀“d”或“D”，但允许省略该后缀。 
变量：使用关键字double来声明double型变量，
例如：double height=23.345,width=34.56D,length=1e12;
对于double型变量，内存分配给8个字节，占64位。
精度:double变量在存储double型数据时保留16位有效数字，实际精度取决于具体数值。

import java.math.*;
/**
 * 测试浮点型
 * @author 荆盼
 *
 */
public class TestPrimitiveDataType2 {

	public static void main(String[] args) {
		float a = 3.14f;
		double b = 6.28;
		double c = 628E-2;
		
		System.out.println(c);
		
		//浮点数是不精确的，不要用于比较。
		float f= 0.1f;
		double d= 1.0/10;
		System.out.println(f==d);//结束为false
		
		float d1 = 423432423f;
		float d2 = d1 +1;
		if(d1==d2) {
			System.out.println("d1==d2");
		}else {
			System.out.println("d1!=d2");
		}
		
		System.out.println("#############");
		//使用精确浮点运算，推荐:BigDecimal。
		BigDecimal bd = BigDecimal.valueOf(1.0);
		bd = bd.subtract(BigDecimal.valueOf(0.1));
		bd = bd.subtract(BigDecimal.valueOf(0.1));
		bd = bd.subtract(BigDecimal.valueOf(0.1));
		bd = bd.subtract(BigDecimal.valueOf(0.1));
		bd = bd.subtract(BigDecimal.valueOf(0.1));
		System.out.println(bd);//0.5
		System.out.println(1.0 - 0.1 -0.1 -0.1 -0.1 -0.1);//0.5000000000000001

		BigDecimal bd2 = BigDecimal.valueOf(0.1);
		BigDecimal bd3 = BigDecimal.valueOf(1.0/10.0);
		
		System.out.println(bd2.equals(bd3));//true	
	}

}

数据转换

Java中数据的基本类型（不包括逻辑类型）按精度从“低”到“高”排列：
byte  short  char int  long  float  double 
 
★当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换。例如：
    float x=100; 

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。如图2-6所示，黑色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会有精度的损失。

/**
 * 测试自动类型转换
 * @author Administrator
 *
 */
public class TestTypeConvert {
	public static void main(String[] args) {
		int a = 324;
		long b = a;
		double d = b;
		//a = b;
		
		//long e = 3.23;
		float f = 23333L;
		
		//特例
		byte b2 = 123;	
	}
}

 
★当把级别高的变量的值赋给级别低的变量时，必须使用显示类型转换运算。显示转换的格式：（类型名）要转换的值;
  例如
    int x=(int)34.89; 
 
★当把一个int型常量赋值给一个byte和short型变量时，不可以超出这些变量的取值范围，否则必须进行类型转换运算；例如，常量128的属于int型常量，超出byte变量的取值范围，如果赋值给byte型变量，必须进行byte类型转换运算（将导致精度的损失），如下所示：
     byte a=(byte)128; 

 

 

 

输入和输出数据

1、输入数据
Scanner是JDK1.5新增的一个类，可以使用Scanner类创建一个对象：
Scanner reader=new Scanner(System.in);
reader对象调用下列方法，读取用户在命令行输入的各种基本类型数据：
nextBoolean()、nextByte()、 nextShort()、 nextInt()、 nextLong()、nextFloat()、nextDouble()。
上述方法执行时都会堵塞，程序等待用户在命令行输入数据回车确认。

import java.util.Scanner;
public class test_Scanner {
	public static void main(String args[]){
		Scanner reader=new Scanner(System.in);	
		int data;
		data = reader.nextInt();
		System.out.println("data的值为：" + data);
	}
}

2、输出数据
用System.out.println()或System.out.print()可输出串值、表达式的值，二者的区别是前者输出数据后换行，后者不换行。
允许使用并置符号：“+”将变量、表达式或一个常数值与一个字符串并置一起输出，如：
System.out.println(m+"个数的和为"+sum);
System.out.println(“:”+123+“大于”+122)  
JDK1.5新增了和C语言中printf函数类似的数据输出方法，该方法使用格式如下：
System.out.printf("格式控制部分"，表达式1，表达式2，…表达式n)
格式控制部分由格式控制符号：%d、%c、%f、%s和普通的字符组成，普通字符原样输出。格式符号用来输出表达式的值。
%d：输出int类型数据值.
%c：输出char型数据.
%f：输出浮点型数据，小数部分最多保留6位.
%s：输出字符串数据。
输出数据时也可以控制数据在命令行的位置，例如：
%md：输出的int型数据占m列  %m.nf：输出的浮点型数据占m列，小数点保留n位。

7 ，变量和常量

在程序中存在大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，有些数据在程序运行过程中值不能发生改变，这些数据在程序中分别被叫做变量和常量。
在实际的程序中，可以根据数据在程序运行中是否发生改变，来选择应该是使用变量代表还是常量代表。

变量

变量代表程序的状态。程序通过改变变量的值来改变整个程序的状态，或者说得更大一些，也就是实现程序的功能逻辑。
为了方便的引用变量的值，在程序中需要为变量设定一个名称，这就是变量名。例如在2D游戏程序中，需要代表人物的位置，则需要2个变量，一个是x坐标，一个是y坐标，在程序运行过程中，这两个变量的值会发生改变。
由于Java语言是一种强类型的语言，所以变量在使用以前必须首先声明，在程序中声明变量的语法格式如下：
 数据类型 变量名称；
 例如：int x；
在该语法格式中，数据类型可以是Java语言中任意的类型，包括前面介绍到的基本数据类型以及后续将要介绍的复合数据类型。变量名称是该变量的标识符，需要符合标识符的命名规则，在实际使用中，该名称一般和变量的用途对应，这样便于程序的阅读。数据类型和变量名称之间使用空格进行间隔，空格的个数不限，但是至少需要1个。语句使用“；”作为结束。
也可以在声明变量的同时，设定该变量的值，语法格式如下：
 数据类型 变量名称 = 值；
 例如：int x = 10；
在该语法格式中，前面的语法和上面介绍的内容一致，后续的“=”代表赋值，其中的“值”代表具体的数据，注意区别“==”代表为判断是否相等。在该语法格式中，要求值的类型需要和声明变量的数据类型一致。
在程序中，变量的值代表程序的状态，在程序中可以通过变量名称来引用变量中存储的值，也可以为变量重新赋值。例如：
 int n = 5；
 n = 10；
在实际开发过程中，需要声明什么类型的变量，需要声明多少个变量，需要为变量赋什么数值，都根据程序逻辑决定，这里列举的只是表达的格式而已。
常量

常量在程序运行过程中主要有2个作用：
   1. 代表常数，便于程序的修改（例如：圆周率的值）
   2. 增强程序的可读性（例如：常量UP、DOWN、LEFT和RIGHT分辨代表上下左右，其数值分别是1、2、3和4）
常量的语法格式和变量类型，只需要在变量的语法格式前面添加关键字final即可。在Java编码规范中，要求常量名必须大写。
则常量的语法格式如下：
  final 数据类型 常量名称 = 值；
  final 数据类型 常量名称1 = 值1， 常量名称2 = 值2，……常量名称n = 值n；
  例如：
  final double PI = 3.14；
  final char MALE=‘M’，FEMALE=‘F’；
在Java语法中，常量也可以首先声明，然后再进行赋值，但是只能赋值一次，示例代码如下：
 final int UP；
  UP = 1；
Final关键字

final 用于声明属性（常量），方法和类， final这个关键字的含义是“这是无法改变的”或者“终态的”；
 那么为什么要阻止改变呢？
 java语言的发明者可能由于两个目的而阻止改变:
 1).效率问题：
 jdk中的某些类的某些方法，是不允许被用户覆盖的，设计者可能认为，所用方法已经是最好的方法，用户私自覆盖，或是由于疏忽而覆盖，就会影响JVM或是系统的系能；
 2). 设计所需：
 众所周知，有些情况必须使用final关键字，比如方法中的匿名内部类的参数传递
 
 【修饰变量】：
  final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
 【修饰方法】：
  final方法不能被子类方法覆盖，但可以被继承。
 【修饰类】：
  final类不能被继承，没有子类，final类中所有方法都是final的。(如String类)

8,运算符和表达式

Java提供了丰富的运算符，如算术运算符、关系运算符、逻辑运算符、位运算符等等。
Java的表达式就是用运算符连接起来的符合Java规则的式子。
运算符的优先级决定了表达式中运算执行的先后顺序。
在编写程序时尽量的使用括号（）运算符号来实现想要的运算次序，以免产生难以阅读或含糊不清的计算顺序。
运算符的结合性决定了并列的相同级别运算符的先后顺序。

算术运行符

1．加减运算符:  +，-
加减运算符是二目运算符；加减运算符的结合方向是从左到右；加减运算符的操作元是整型或浮点型数据，加减运算符的优先级是4级。
 2．乘、除和求余运算符： *，/，%
以上运算符是二目运算符，结合方向是从左到右，乘、除和求余运算符的操作元是整型或浮点型数据。运算符的优先级是3级。
3．算术表达式
  用算术符号和括号连接起来的符合java语法规则的式子，称为算术表达式。
4．自增自减运算符：++，--
是单目运算符，可以放在操作元之前，也可以放在操作元之后。操作元必须是一个整型或浮点型变量。作用是使变量的值增1或减1，如：
++x（--x）表示在使用x之前，先使x的值增（减）1。
x++（x--）表示在使用x之后，使x的值增（减）1。
 精度从“低”到“高”排列的顺序是：
   byte  short  char  int  long  float  double
Java在计算算术表达式的值时，使用下列计算精度规则：
1．如果表达式中有双精度浮点数（double型数据），则按双精度进行运算。
2．如果表达式中最高精度是单精度浮点数（float型数据），则按单精度进行运算。
3．如果表达式中最高精度是long型整数，则按long精度进行运算。
4．如果表达式中最高精度低于int型整数，则按int精度进行运算。

public class TestOperator01 {

	public static void main(String[] args) {
		//byte a = 1;
		//int b = 2;
		//long b2 =3;
		//byte c = a+b;	//报错
		//int c2 = b2+b; //报错
		
		
		float f1 = 3.14f;
		
		//float d = b+ b2;
		
		//float d2 = f1 +6.2; //报错
		
		System.out.println(9%5);
		System.out.println(-9%5);
		
		
		int a = 3;
		int b = a++; //执行完后b=3,先给b赋值，再自增。
		System.out.println("a="+a+"\nb="+b);
		a=3;
		b=++a;//执行完后，b=4,a先自增，再给c赋值
		System.out.println("a="+a+"\nb="+b);	
	}
}

 

关系运算符

关系运算符是二目运算符，用来比较两个值的关系。关系运算符的运算结果是boolean型，当运算符对应的关系成立时，运算结果是true，否则是false。 

/**
 * 测试关系运行符
 * @author 
 *
 */
public class TestOperator02 {

	public static void main(String[] args) {
		int a = 3;
		System.out.println(a==3);
		System.out.println(a!=3);
		System.out.println(a<5);
		
		char b = 'a';
		char b2 ='c';
		
		System.out.println((int)b);
		System.out.println(0+b);
		System.out.println(0+b2);
		System.out.println(b<b2);
	}
}

 

逻辑运算符

逻辑运算符包括：&&，||，!
其中&&、||为二目运算符,实现逻辑与、逻辑或。
！为单目运算符实现逻辑非。
逻辑运算符的操作元必须是boolean型数据，逻辑运算符可以用来连接关系表达式。 

/**
 * 测试逻辑运算符
 * @author Administrator
 *
 */
public class TestOperator03 {
	public static void main(String[] args) {
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b1&b2);
		System.out.println(b1|b2);
		System.out.println(b1^b2);
		System.out.println(!b2);
		
		
		//短路
		//int c = 3/0;
		System.out.println(1>2 && 1>(3/0)); //短路与，第一个操作数的值为false,则不需要在计算后面的操作数。
		System.out.println(2>1 || 1>(3/0));//短路或，第一个操作数的值为false,则不需要在计算后面的操作数。
	}
}

 

位运算符

两个整型数据实施位运算，即对两个整型数据对应的位进行运算得到一个新的整型数据。
1．按位与”运算
“按位与”运算符“&”是二目运算符。
2．按位或”运算
“按位或”运算符：“|”是二目运算符。
3．按位非”运算
“按位非”运算符：“~”是单目运算符。
4．按位异或”运算
“按位异或”运算符：“^”是二目运算符。

/**
 * 测试位运算符
 * @author Administrator
 *
 */
public class TestOperator04 {

	public static void main(String[] args) {
		int a = 3;
		int b =4;
		System.out.println(a&b);//0
		System.out.println(a|b);//7
		System.out.println(a^b);
		
		/*以3为例：
		 * 二进制原码： 0000 0000 0000 0000 0000 0000 0000 0011
		 * 取反操作后 ：1111 1111 1111 1111 1111 1111 1111 1100
		 * 在Java中，有符号整数都是用补码来表示，而补码=反码+1
		 * 1.先求反码：1000 0000 0000 0000 0000 0000 0000 0011
		 * 2.再求补码：1000 0000 0000 0000 0000 0000 0000 0100
		 * 最高位代表符号位 1表示负数,0表示正数，所以结果是-4。
		 * */
		System.out.println(~a);//-4,
		
		//移位运算
		int c = 3<<2;
		System.out.println(c);//12
		System.out.println(12>>2);//3	
	}
}

 

其它
1、赋值运算符和赋值表达式：=
赋值运算符是二目运算符，左面的操作元必须是变量，不能是常量或表达式。
赋值运算符的优先级较低，是14级，结合方向右到左。
赋值表达式的值就是“=”左面变量的值。
注意：不要将赋值运算符“=”与关系运算符“==”混淆。
2、instanceof运算符
instanceof 运算符是二目运算符，左面的操作元是一个对象；右面是一个类。当左面的对象是右面的类或子类创建的对象时，该运算符运算的结果是true ，否则是false。 

字符串连接符

/**
 * 测试字符串运算符
 * @author Administrator
 *
 */
public class TestOperator05 {

	public static void main(String[] args) {
		String a = "3";
		int b = 4;
		int c = 5;
		char d= 'a';
		System.out.println(a+b);//34
		System.out.println(a+c);//35
		System.out.println(b+c);//9
		System.out.println(a+b+c);//345
		System.out.println(b+c+a);//93
		System.out.println(d);//97
		System.out.println(d+3);//100
	}
}

条件运算符

public class TestOperator06 {
	/**
	 * 测试条件运行符（三元运行符）
	 * @param args
	 */
	public static void main(String[] args) {
		int score = 80;
		int x = -100;
		String type = score<60?"不及格":"及格";
		System.out.println(type);
		if(score<60) {
			System.out.println("不及格");
		}else {
			System.out.println("及格");
		}	
		System.out.println(x>0?1:(x==0?0:-1));//-1
	}
}

运算符优先级_逻辑与或优先问题

逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（逻辑非>逻辑与>逻辑或）如：

a||b&&c的运算结果是:a||(b&&c),而不是(a||b)&&c。

9，流程控制语句

控制语句分为条件分支语句、开关语句和循环语句。

条件语句

条件分支语句按着语法格式可细分为三种形式，
if语句
if-else语句
if-else if- ……-else 语句

if语句

if语句是单条件分支语句，即根据一个条件来控制程序执行的流程。
if 语句的语法格式：
if（表达式）{
   若干语句
} 

 

if-else语句

if-else 语句是双条件分支语句，即根据一个条件来控制程序执行的流程。 
if-else 语句的语法格式：
if(表达式){
         若干语句
 }
else {
 若干语句
 }

if-else if- ……-else 语句

if-else if-else 语句是多条件分支语句，即根据多个条件来控制程序执行的流程。 
if-else if-else语句的语法格式：
if(表达式){
       若干语句
 }
else if(表达式){ 
       若干语句
 }
… …
else {
若干语句
 }

public class Demo9{
	public static void main(String args[]){
		int a=12,b=21;
		if(a==1){
			System.out.println("a");
		}else if (b==2){
			System.out.println("b");
		}else{
			System.out.println("c");
		}
			
	}
}

开关语句

switch 语句是单条件多分支的开关语句，它的一般格式定义如下(其中break语句是可选的）： 
switch(表达式)
{
  case 常量值:
              若干个语句
              break;
  case  常量值:
              若干个语句
              break;
    ...
  case  常量值n:
              若干个语句
             break;
   default:
         若干语句
}
switch语句中的“表达式”和“常量值”的值必须为byte、short、int、char型或者枚举类型，而且互不相同。

import java.util.Scanner;
public class Demo9{
	public static void main(String args[]){
		Scanner reader = new Scanner(System.in);
		System.out.println("please input int");
		int input = reader.nextInt();
		switch(input){
			case 1:
			System.out.println("you input 1");
			break;
			
			case 2:
			System.out.println("you input 2");
			break;
			
			default:
			System.out.println("you input other");
			break;
		}
	}
}

 带标签的Break和continue

“标签”是指后面跟一个冒号的标识符，例如：“label”,对java来说唯一用到的标签的地方是在循环语句之前。而在循环之 前

设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，这弱就会中断到存在标签的地方。

/**
 * 
 * @author Administrator
 *
 */
public class TestLabelContinue {
	//打印101~150之间的所胡函数
	public static void main(String[] args) {
	outer:	for(int i = 101;i < 150;i++) {
			for (int j=2; j< i/2;j++){
				if(i%j == 0) {
					continue outer;
				}		
			}
			System.out.println(i+" ");
		}

	}

}

 

循环语句

for循环

for语句的语法格式：
for (表达式1;表达式2;表达式3){
   若干语句
}
for语句的执行规则是：
（1）计算“表达式1”，完成必要的初始化工作。
（2）判断“表达式2”的值，若“表达式2”的值为true，则进行（3），否则进行（4）。
（3）执行循环体，然后计算“表达式3”，以便改变循环条件，进行（2）。
（4）结束for语句的执行。

 

while循环

while语句的语法格式：
while (表达式) {
  若干语句
}
while语句的执行规则是：
（1）计算表达式的值，如果该值是true时，就进行（2），否则执行（3）。
（2）执行循环体，再进行（1）。
（3）结束while语句的执行。
 

do...while语句

do-while语句的语法格式：
do {
   若干语句
 } while(表达式);
do- while语句的执行规则是：
 （1）执行循环体，再进行（2）。
 （2）计算表达式的值，如果该值是true时，就进行（1），否则执行（3）。
 （3）结束while语句的执行。

 

 

break和 continue语句

break和continue语句是用关键字break或continue加上分号构成的语句。
在循环体中可以使用break语句和continue语句。
如果在某次循环中执行了break语句，那么整个循环语句就结束。
如果在某次循环中执行了continue语句，那么本次循环就结束，即不再执行本次循环中循环体中continue语句后面的语句，而转入进行下一次循环。
 

import java.util.Scanner;
public class Demo9{
	public static void main(String args[]){
		// int a=1,b=2;
		// if(a==1){
			// System.out.println("a");
		// }else if (b==2){
			// System.out.println("b");
		// }else{
			// System.out.println("c");
		// }
		
		// Scanner reader = new Scanner(System.in);
		// System.out.println("please input int");
		// int input = reader.nextInt();
		// switch(input){
			// case 1:
			// System.out.println("you input 1");
			// break;
			
			// case 2:
			// System.out.println("you input 2");
			// break;
			
			// default:
			// System.out.println("you input other");
			// break;
		// }
		
		for(int i=0;i<10;i++){
			System.out.println(i);
			if(i==5){
				continue;
			}
			System.out.println(i);
		}
		
		// int i=0;
		// while(i<10){
			// System.out.println(i);
			// i++;
		// }
		
		// int i=0;
		// do{
			// System.out.println(i);
			// i++;
		// }while(i<10);
		
	}
}

11，数组

数组是相同类型的变量按顺序组成的一种复合数据类型，称这些相同类型的变量为数组的元素或单元。数组通过数组名加索引来使用数组的元素。
数组属于引用型变量，创建数组需要经过声明数组和为数组分配变量两个步骤。 

声明数组

声明数组包括数组变量的名字(简称数组名)、数组的类型。
声明一维数组有下列两种格式：
数组的元素类型   数组名[];
数组的元素类型 []  数组名;
例如： float  boy[];
          float[] boy;
声明二维数组有下列两种格式：
数组的元素类型   数组名[][];
数组的元素类型 [][] 数组名;
例如： char  cat[][];
          char[][]  cat;
 
分配数组

声明数组后，还必须为它分配内存空间，为一维数组分配内存空间的格式如下：
数组名字 = new  数组元素的类型[数组元素的个数];
例如： float boy[];
          boy= new float[4];
声明数组和创建数组可以一起完成，例如：
float boy[]=new float[4]; 

 
二维数组和一维数组一样，在声明之后必须用new运算符为数组分配内在空间。
例如： int  mytwo[][]; 
          mytwo = new int [3][4];
声明数组和创建数组可以一起完成，例如：
int mytwo[][] = new int[3][4]; 
Java采用“数组的数组”来声明多维数组。上述创建的二维数组mytwo就是由3个长度为4的一维数组：mytwo[0]、mytwo[1]和mytwo[2]构成的。

12 枚举

枚举定义

JDK1.5 引入了一种新的数据类型枚举类型。Java使用关键字enum声明枚举类型，语法格式如下：
      enum 名字
      { 常量列表
      }
        其中的常量列表是用逗号分割的字符序列，称为枚举类型的常量。例如：
      enum Season
      {  spring, summer, autumn, winter   
      }
声明了名字为Season的枚举类型，该枚举类型有4个常量。

枚举变量

enum Season
{ spring, summer, autumn, winter   
 }
      声明了名字为Season的枚举类型，该枚举类型有4个常量。
      声明了一个枚举类型后，就可以用该枚举类型声明一个枚举变量，例如：Season x; 该枚举变量只能取值枚举类型中的常量。通过使用枚举名和“.”运算符获得枚举类型中的常量。例如：x=Season.spring。 

注意事项

1．使用for语句遍历枚举常量
枚举类型可以用如下形式返回一个一维数组：
枚举类型的名字.values(); 该一维数组元素的值和该枚举类型中常量依次相对应。例如，
Season[]=Season.values();
那么，a[0]至a[3]的值依次为：spring, summer, autumn, winter。
2．switch语句中使用枚举常量 
JDK1.5后的版本允许switch语句中表达式的值是枚举类型的常量。

public class Demo11{
	public static void main(String args[]){
		Weekday w = Weekday.Sunday;
		if (w == Weekday.Sunday )
			 System.out.println(w);
		
		for(Weekday x:Weekday.values()){
			System.out.println(x);
		 }
		
		Weekday w1 = Weekday.Monday;
		switch(w1){
			case Monday:
				System.out.println("Monday");
			break;
			case Sunday:
				System.out.println("Sunday");
			break;
		}
	}
	//枚举类型 Weekday。
	public enum Weekday{
		Monday,Thesday,Wednesday,Thursday,Friday,Saturday,Sunday
	}
}

13 初识eclipse

Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。
虽然大多数用户很乐于将 Eclipse 当作 Java 集成开发环境（IDE）来使用，但 Eclipse 的目标却不仅限于此。Eclipse 还包括插件开发环境（Plug-in Development Environment，PDE），这个组件主要针对希望扩展 Eclipse 的软件开发人员，因为它允许他们构建与 Eclipse 环境无缝集成的工具。由于 Eclipse 中的每样东西都是插件，对于给 Eclipse 提供插件，以及给用户提供一致和统一的集成开发环境而言，所有工具开发人员都具有同等的发挥场所。
这种平等和一致性并不仅限于 Java 开发工具。尽管 Eclipse 是使用Java语言开发的，但它的用途并不限于 Java 语言；例如，支持诸如C/C++、COBOL、PHP、Android等编程语言的插件已经可用，或预计将会推出。

3.3  语句

 

 

下载安装，熟悉使用

Ctrl+1 快速修复（最经典的快捷键,就不用多说了，可以解决很多问题，比如import类、try catch包围等）
Ctrl+Shift+F 格式化当前代码
Ctrl+Shift+M 添加类的import导入
Ctrl+Shift+O 组织类的import导入（既有Ctrl+Shift+M的作用，又可以帮你去除没用的导入，很有用）
Ctrl+Y 重做（与撤销Ctrl+Z相反）
Alt+/ 单次补全和内容辅助（帮你省了多少次键盘敲打，太常用了）
Ctrl+D 删除当前行或者多行
Alt+↓ 当前行和下面一行交互位置（特别实用,可以省去先剪切,再粘贴了）
Alt+↑ 当前行和上面一行交互位置（同上）
Ctrl+Alt+↓ 复制当前行到下一行（复制增加）
Ctrl+Alt+↑ 复制当前行到上一行（复制增加）
Shift+Enter 在当前行的下一行插入空行（这时鼠标可以在当前行的任一位置,不一定是最后）
Ctrl+/ 注释当前行,再按则取消注释
Alt+Shift+R 重命名 
Ctrl+K 参照选中的Word快速定位到下一个
Ctrl+O 快速显示 OutLine
Ctrl+T 快速显示当前类的继承结构

Alt+Enter 显示当前选择资源（工程,or 文件 or文件）的属性
Shift+Enter 在当前行的下一行插入空行（这时鼠标可以在当前行的任一位置,不一定是最后）
Shift+Ctrl+Enter 在当前行插入空行（原理同上条）
Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某行 （对于程序超过100的人就有福音了）
Ctrl+M 最大化当前的Edit或View （再按则反之）
Ctrl+/ 注释当前行,再按则取消注释
Ctrl+W 关闭当前Editer
Ctrl+E 快速显示当前Editer的下拉列表（如果当前页面没有显示的用黑体表示）
Ctrl+/（小键盘） 折叠当前类中的所有代码
Ctrl+×（小键盘） 展开当前类中的所有代码
Ctrl+Space 代码助手完成一些代码的插入（但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替）
Ctrl+Shift+E 显示管理当前打开的所有的View的管理器（可以选择关闭,激活等操作）
Ctrl+J 正向增量查找（按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了）
Ctrl+Shift+J 反向增量查找（和上条相同,只不过是从后往前查）
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X 把当前选中的文本全部变为大写
Ctrl+Shift+Y 把当前选中的文本全部变为小写
Ctrl+Shift+P 定位到对于的匹配符（譬如{}） （从前面定位后面时,光标要在匹配符里面,后面到前面,则反之）
Alt+Shift+M 抽取方法 （这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用）
Alt+Shift+C 修改函数结构（比较实用,有N个函数调用了这个方法,修改一次搞定）
Alt+Shift+L 抽取本地变量（ 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候）
Alt+Shift+F 把Class中的local变量变为field变量 （比较实用的功能）
Alt+Shift+I 合并变量（可能这样说有点不妥Inline）
Alt+Shift+V 移动函数和变量（不怎么常用）
Alt+Shift+Z 重构的后悔药（Undo）