java基础1（注释、关键字、标识符、变量常量、数据类型、运算符、流程控制）

                      java基础1（注释、关键字、标识符、

                        变量常量、数据类型、运算符、流程控制）

1. java概述

1.1 java的技术体系

                      Java SE：是Java的标准版，提供了完整的java核心API。

                      Java EE：是Java的企业版，主要用于开发企业级分布式网络程序系统，核心为EJB（企业Java组件模型）。

                      Java ME：主要用于嵌入式系统开发。

1.2 Java语言特点

                      （1）简单性：语言省略所有难以理解和困惑的特点在C++语言，如头文件、指针、结构、单元、运算符重载、虚拟基础类，等它更简洁严谨；

                      （2）面向对象：两个基本概念“类”和“对象”；三大特征“封装”，“继承”，“多态”；

                      （3）跨平台性：自带解释器，在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机，在不同的系统平台上都可以运行；

                      （4）既是编译执行的语言，也是解释执行的语言：源文件通过编译，形成一个文件（不是二进制文件），而是“字节码的文件.class”，这个自节码文件是跨平台 的文件（java的内部会有自己的解释器（虚拟机）），使用自带的“解释器”解释执行.class。

 

2. Java程序的编写流程

2.1 Java应用程序的编写流程如下：

                      （1）编写源文件：编写Java源文件，他的扩展名为.java；

                      （2）编译：通过编译器把源文件编译成字节码文件，字节码文件的扩展名为.class；

                      （3）运行：使用解释器来运行字节码文件

2.2 源文件代码编写

                      在e盘下新建一个文本文档,文件名为MyFirstCode.java，内容如下：

public class MyFirstCode {
    public static void main(String[] args) {
        System.out.println("This is my fisrt code");
    }
}

2.3 编译源代码文件

                      编译操作需要使用编译器来完成，它属于JDK的一部分，在安装JDK的时候已经安装好了，位置位于JDK的bin目录             下的javac.exe，使用DOS命令来运行它，如下图。

                     

                     在编译时控制台上不会有输出，如果有输出说明源代码有错误，所以大家一旦编译出错，就要去查看源文件中是否           存在错误，正确编译后会在源文件同目录下生成字节码文件，扩展名为.class。

                                 

2.4 运行字节码文件

                      运行字节码文件需要使用java.exe命令，它与javac.exe在同一目录下，运行字节码文件与编译不同的是需要进入到           字节码文件所在的目录，并且在运行字节码文件是不要加扩展名，运行如下图。

                     

2.5 简化编译和运行操作

                      可以发现每次程序编译与运行都要输入E:\ProgramFiles\jdk-8u144\bin后，才能使用javac.exe与java.exe，这样的           方式很麻烦，通过通过配置Windows的PATH环境变量就可以在不同位置编译运行。

                      配置PATH环境变量：鼠标右键点击计算机  →  属性  →  高级系统设置  →  点击环境变量  →  找到系统变量中的           PATH  →  点击编辑按钮。将JDK安装目录\bin路径（我的电脑上的E:\ProgramFiles\jdk-8u144\bin）配置到PATH变量中，用         英文分号与其他变量隔开。还可如下配置环境变量：

                      （1）创建变量：变量名为:JAVA_HOME 变量值：安装JDK的目录；

                      （2）修改Path变量：在末尾添加信息:   ;%JAVA_HOME%\bin;

                      （3）配置classpath:  .;%JAVA_HOME%\lib\tools.jar。

 

3. 注释

Java中提供了三种注释方式，分别是：

                      （1）单行注释    //注释内容

                      （2）多行注释    /*注释内容*/

                      （3）文档注释 /**注释内容*/

文档注释的使用：javadoc –d 生成目录 –version –author 类名

4. 关键字

关键字是被Java语言赋予特殊含义，具有专门用途的单词，Java中的关键字均为小写关键字如下：

                                       

5. 标识符

5.1 定义

                      在Java程序中，其实标识符就是名称的意思，除了关键字以外基本上都是标识符了，在定义类、方法、变量时总               要给它们起名字，这些名字就是标识符。

5.2 组成元素

                      （1）英文字母： a-zA-Z

                      （2）数字：0-9

                      （3）符号：_和$

5.3 规则

                      （1）不能以数字开头；

                      （2）不可以使用关键字

                      （3）严格区分大小写

 

6. 变量与常量

6.1 常量

                      在程序运行过程中一直不会改变的的量称为常量，通常也被称为“final变量”，。常量在整个程序中只能被赋值                     一 次。在Java中声明一个常量除了要指定数据类型外。还需要通过final关键字进行限定，语法如下：

                      final 数据类型 常量名 [ = 值 ]

                      常量名通常使用大写字母，但这并不是必须的，是为了清除的表名变量。

        6.2 变量

                      在程序运行过程中其值能被改变的量称为变量，可以看成是存储数据的“盒子”。定义变量就是要告诉编译器这个变            量的数据类型，这样编译器才知道要分配多少内存给它，以及它能存放什么样的数据。在程序运行过程中，空间内的值是            变化的，这个内存空间就称为变量。内存空间内的值就是变量值。语法如下：

                      变量类型  变量名  [ =  变量值]              []中的叫做变量的初始化

                      内存分配方式：

                                 （1）基本数据类型：占用一块内存，如局部变量int i=1;在内存里面只分配了一块内存，里面存放的就是值                        1，储到栈内存中，使用i这个名字来访问这块内存。

                                 （2）引用数据类型：占用两块内存，如 String s此时为引用变量s分配了一块内存，但是目前这个内存什么                        也没有存，因为此时s不指向任何一个对象，所以是null。当s=new String(“hi”)使用new创建了一个对象后，又分配                        一块内存（堆），这个对象的内容“hi”就存放在新分配的内存中。而之前给s分配的内存也有了内容，根据这                                 个内容就可以找到第二块内存，使用其中的内容（“hi”）

7. 数据

7.1 数据类型

                      Java中的数据类型分为基本数据类型和引用数据类型。

                      引用数据类型(无限个数)：类，接口，数组 ，String 等(它用双引号)

        7.2 数据类型分类

四类	八种	字节数	范围
整型	byte	1	-2^7~2^7-1
	short	2	-2^15~2^15-1
	int	4	-2^31~2^31-1
	long	8	-2^63~2^63-1
浮点型	float	4	-3.403E38～3.403E38
	double	8	-1.798E308～1.798E308
字符型	char	2	表示一个字符
布尔型	boolean	1	只有两个值true与false

 

        7.3 类型的转换

                2.2.1.高低的级别：

                      byte,short,char=>int=>long=>float=>double其中，boolean类型不能跟其他类型之间做转换。

                2.2.2.自动类型转换（隐式转换，宽向型转换）：

                        将第类型赋值给高类型，如：Short s=10;Int i=20;i=s;

                2.2.3.强制类型转换：

                        将高类型赋值给低类型，需要强制装换，格式：低类型  变量=（低类型）变量。

                        注意：强制类型转换可能会丢失精度，代码如下

                        int i = 357;                             //4字节  32位的二进制数

                        byte b = (byte)i;                     //1字节 8位的二进制

                        System.out.println(b);            // 结果为101

                2.2.4.字符串和其它类型转换：

                      字符串和其它类型转换会提升成String类型

8. 运算符

        8.1 算术运算符

               

运算符	运算规则	范例	结果
+	拼接字符串	"拼" + "接"	拼接
+	正号	+1	1
+	加	1+2	3
-	负号	-1	-1
-	减	2-1	1
*	乘	1*2	2
/	除	5/2	2
%	取余	3/2	1
++	自加	int a=1;              a++/++a	2
--	自减	int b=3;                a--/--a	2

                注意：%取余操作和取模操作的区别，在于商：取余操作：商向0取整；模操作：商向下取整

                           ++：前置++  后置++：无论是前置还是后置，都对原来的变量进行+1， 对于表达的结果不同，后置++（会缓                              存变量之前的值）指向的是变量+1之前的结果。

        8.2 赋值运算符

 

运算符	运算规则	范例	结果
=	赋值	int i=2；	2
+=	加后赋值	int i= 2，i+=1	3
-=	减后赋值	int i= 2，i-=1	1
*=	乘后赋值	int i= 2，i*=1	2
/=	除后赋值	int i= 2，i/=1	2
%=	取余后赋值	int i= 2，i/=1	0

               

        8.3 比较（关系）运算符

               

运算符	运算规则	范例	结果
==	相等于	2==2；	True
！=	不等于	2!=2；	False
<	小于	2<1	False
>	大于	2>1	True
<=	小于等于	2<=1	False
>=	大于等于	2>=1	True

 

                注意：==如果两侧都是基本数据类型，则比较的是值大小；如果两侧都是引用类型，则比较的是地址是否是同一个

        8.4 逻辑运算符

           

运算符	运算规则	范例	结果
&	与	false&true	False
|	或	false|true	True
！	非	!true	False
^	异或	false^true	True
&&	短路与	false&&true	False
||	短路或	false||true	True

 

                短路现象：&& 第一个表达式为false，则后面的表达式不执行

                                  || 第一个表达式为true，则后面表达式不执行

        8.5 位运算符

               

符号	运算规则	范例	结果
>>	右位移	12 >> 2	3
<<	左位移	12 << 2	48
>>>	无符号右位移	12>>> 2	3
&	按位与	12 & 9	8
｜	按位或	12| 9	13
^	按位异或	12^ 9	5

 

                位运算符是对于补码进行的按位操作：

                                 &  :如果两个都是1，则返回1，否则返回0

                                 |  :  如果两个都是0，则返回0，否则返回1

                                 ^  :  如果两个相同，则返回0，否则 ，返回1

                                 ~ ：一元运算符，对于某一个数的补码进行按位取反，包括符号位。

        8.6 三元运算符

               

                语法： 条件表达式?值1：值2

                规则：如果条件表达式返回为真，取值1，否则取值2；值1表达式的类型和值2的表达式类型一致

        8.7 运算符的优先级

优先级	描述	运算符
1	括号	()、[]
2	正负号	+、-
3	自增自减，非	++、--、!
4	乘除，取余	*、/、%
5	加减	+、-
6	移位运算	<<、>>、>>>
7	大小关系	>、>=、<、<=
8	相等关系	==、!=
9	按位与	&
10	按位异或	^
11	按位或	|
12	逻辑与	&&
13	逻辑或	||
14	条件运算	?:
15	赋值运算	=、+=、-=、*=、/=、%=
16	位赋值运算	&=、|=、<<=、>>=、>>>=

 

                优先级：  ()调整优先级

                                大体遵循规则：

                                算术运算符> 比较运算符 > 位运算符> 逻辑运算符> 赋值运算符

                                ！优先级别最高

               

9. 流程控制

9.1 顺序结构

                      程序从上到下，从左到右执行。

9.2 分支结构

                      if结构语法，有3种如下：

                                （1） if（条件表达式）{

                                                     //执行语句

                                           }

int i = 2;
if(i == 2) {
    System.out.println(i);
}

                                （2） if（条件表达式）{

                                                     //执行成立语句1

                                           }else {

                                                     //执行不成立语句2

                                           }

int x = 5;
int y = 2;
if(x==3) {
	y = x + y;
}else {
	y = x - y;
}
System.out.println(y);

                                （3） if（条件表达式1）{

                                                     //执行语句2

                                           }else if（条件表达式2）{

                                                     //执行语句2

                                           }else {

                                                     //执行语句3

                                           }

int x = 10;
	int y = 0;
	if(x>=3) {
		y = 2 * x + 1;
	}else if(-1

                      注意：（1）分支语句中执行语句只有一个表达式可以省略大括号，否则不能省略。

                                 （2）多分支语句中将条件范围小的放在最前面；如果前面的条件成立，后面的条件即使成立也不执行。

                      switch结构语法：

                                switch（变量/常量）{

                                           case 值1：

                                                      //执行1；

                                           break；

                                           case 值2：

                                                      //执行2；

                                           break；

                                          ......

                                           defualt：

                                                      //执行3；

                                           break；

                                }

                      注意：（1）变量/常量的类型只能是：byte，short，int，char，String（jdk1.7后），枚举；

                                 （2）当省略break时，顺序从满足条件的语句从上到下执行，与case无关；

                                 （3）case块中的值是唯一的，并且是等值比较的。

int score = 99;
switch (score / 10) { 
	case 9:
	case 10:
		System.out.println("A");
		break;
	case 8:
		System.out.println("B");
		break;
	case 7:
		System.out.println("C");
		break;
	case 6:
		System.out.println("D");
		break;
	default:
		System.out.println("不及格");
		break;

}

9.3 循环

                      for循环

                                 for（初始值表达式①，条件表达式②，迭代④）{

                                            //执行③

                                 }

//水仙花树(100~500)     153=1*1*1+5*5*5+3*3*3
for(int i=100;i<500;i++) {
	int theUnit = i%10;
	int decade = i/10%10;
	int hundred = i/100;
	if(i==theUnit *theUnit *theUnit +decade *decade *decade +hundred *hundred *hundred ) {
		System.out.println(i);
	}
}

                      while循环

                                初始值①

                                 while（条件表达式②）{

                                            //执行③

                                            //迭代④

                                 }

//100以内能被5整除的数的和
int sum = 0;  
int i=1; //初始值 1
while(i<=100) { 
    if(i%5==0) {
    	sum += sum;
    }
	i++;
}

                      do while循环

                                 //初始值①

                                 do{

                                            //执行②

                                            //迭代③

                                 }while(条件表达式④);

//输入字母，如果为q则退出系统
Scanner in=new Scanner(System.in);
System.out.println("请输入字母, 输入q则退出系统");
String letter ="";
do
{
	letter=in.nextLine();
}
while (!letter.equals("q"));
System.out.println("退出系统");

                      foreach循环（增强for循环）

                                 for（类型 对象 : 数组或集合）{

                                            //执行操作

                                 }

                      注意：（1）按照①-④的循序执行；

                                 （2）for循环和while循环的特点：先判断，后执行；do while先执行一次再判断；增强for循环用于变量数组                        或集合。

//遍历数组
int[] array = new array[]{11,22,33,44,55,66};
for(int every : array){
    System.out.println(every + " ");
}

9.4 嵌套循环

                      在一个循环中又嵌套另一个循环结构。

                      嵌套循环特点：外层循环执行一次，内层循环执行全部。

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

9.5 关键字break与continue

                      break（终止，打断）：只能出现在switch语句和循环结构中；在循环中表示终止循环；后面不能跟输出语句；

                      continue（继续）：只能出现在循环结构中；表示结束当前循环，进入下一次循环；

                      循环标号见如下代码：

label:for(int i=2;i<=100;i++) {		 
			for(int j=2;j<=Math.sqrt(i);j++) {     
				if(i%j==0) {
					continue label;
				}
			}
			
		}

                      break和continue都遵循就近原则。正常的break只退出一重循环，你可以用标号标出你想退出哪一个语句。