兔C_Java集：Java 程序基本概念

1. 注释

在程序中，由于其基本组成都是代码，所以考虑到程序可维护性的特点，在编些代码时需要在某些特定段落上增加文字的叙述作用的说明，这些文字不被编译器编译。也就是注释。

Java 的注释有三种形式：

1. // 单行注释
2. /* 多行注释 */
3. /**
   *文
   *档
   *注
   *释
   */

下面进行更详细的叙述：

单行注释

就是在需要注释的内容前面加上双斜线 //，Java 编译器在进行程序编译时会忽略掉这部分。

public class Hello{
	public static void main(String args[]){
		//换行输出语句
		System.out.println("Hello~Java");
	}
}

多行注释

在注释内容前面以单斜线加一个星形标记 ( /* ) 开头，并在注释内容末尾以一个星形标记加单斜线( */ )结束。当注释内容超过一行时一般使用这种方法。

public class Hello{
	/*
	 *此处为多行注释,编译时不被编译
	 */
	public static void main(String args[]){
		//换行输出语句
		System.out.println("Hello~Java");
	}
}

文档注释

以单斜线加两个星形标记开头 (/**) 开头，并以一个星形标记加单斜线 (*/) 结束。文档注释的内容会被解释成程序的正式文档，并能包含进入 javadoc 工具生成的文档里，用以说明该程序的层次结构及其方法。

/**
 * 此处为文档注释内容
 * @author 兔C
 */
public class Hello{
	public static void main(String args[]){
		//换行输出语句
		System.out.println("Hello~Java");
	}
}

2. 标识符与关键字

public class 类名称{}

实际上这里的类名称就属于一个标识符。除类名之外，属性名、方法名称等也都属于标识符的定义范围。
在 Java 中标识符有严格的定义要求：由 字母、数字、_下划线、$美元符号组成。其中不能以数字开头。也不能定义为 java 中的关键字。

标识符 和 关键字 的区别

所谓的关键字是指具备特殊含义的单词，例如：public、class、static。凡官方定义的具有特殊含义的单词，都属于关键字。其特点在于全部用小写字母的形式表示。
而标识符则是我们自己在程序编写过程中去定义的名称。

3. 数据类型

任何的程序严格来讲都属于是对数据的处理游戏，所以对数据的保存就必须有严格的限制，这些限制就体现在了对数据类型的划分上。
不同的数据类型可以保存不同的数据内容，Java 的数据类型分为 基本数据类型和引用数据类型两种。

其中，基本数据类型又包括：byte、short、int、long、float、double、char、boolean。
而引用数据类型在操作时候必须要进行内存的开辟。
两者的区别也是在于：基本数据类型不牵扯内存分配问题，而引用数据类型需要由开发者为其分配空间。

基本数据类型大小、范围、默认值

No	数据类型	大小/位	可表示的数据范围	默认值
1	byte(字节)	18	-128 ~ 127	0
2	short(短整型)	16	-32768 ~ 32767	0
3	int(整型)	32	-2147483648 ~ 2147483647	0
4	long(长整型)	64	-9223372036854775808~9223372036854775807	0.0
5	float(单精度)	32	-3.4E38(-3.4 * 10^38) ~ 3.4E38(3.4 * 10^38)	0.0
6	double(双精度)	64	-1.7E308(-1.7 * 10^308) ~ 1.7E308(1.7 * 10^308)	0.0
7	char(字符)	16	0 ~ 255	‘\u0000’
8	boolean(布尔)	-	true 或 false	false

数据类型的使用

整型

任何一个数字常量，在 Java 中都属于 int 数据类型。

public class Test_int{
	public static void main(String args[]){
		//数据类型 变量名称 = 常量;
		int num = 10;
		int result = num *2;
		System.out.println("result的值为："+result);
	}
}

由于时间关系，除非必须放置效果图展示的代码段之外，不再放置程序执行效果图。

问：什么是常量？什么是变量？？

变量和常量的本质区别在于：常量内容是固定的，而变量的内容是可以改变的。
变量的使用需要提前声明，声明数据类型并将内存中某个内存块保留下来以供程序使用。
常量是一个固定的值，不可改变。

如：在上述代码段中，变量有：num 和 result，
而常量值有：10、2

使用数据类型存储数据超过取值范围的溢出问题

public class Test_SpillInt {
    public static void main(String[] args) {
        //取 int 最大值
        int max = Integer.MAX_VALUE;

        //取 int 最小值
        int min = Integer.MIN_VALUE;
        System.out.println("int 类型的最大值为："+max);
        System.out.println("int 类型的最小值为："+min);
        System.out.println();

        System.out.println("最大值 +1："+ (max+1));
        System.out.println("最小值 -1："+ (min-1));
        System.out.println("最小值 -2："+ (min-2));

    }
}

其运行结果为：

最大值 +1 结果成了最小的值，最小值 -1 结果成了最大的值。

为什么？？

在计算机中二进制是基本的组成单元，而 int 型数据一共占32位长度，也就是说第一位是符号位，其余的31位都是数据位。当数据已经是该数据类型保存的最大值时，如果继续进行 +1 的操作就会造成符号位上的变更。最终，就会造成这种数据溢出的问题。

想解决这一为题，可以通过转型来实现。也就是将当前数据类型转向更大的数据类型。

比 int 更大的数据类型是 long。而 int 转型为 long 有两种方式：

1. 转换为 long 型常量，使用 “数字L” 。
2. 第二种使用 (long) 变量名称。实际上可以用此类方式实现各种数据类型的转换：(目标数据类型) 变量。

改善溢出问题

public class Test_SpillInt {
    public static void main(String[] args) {
        //取 int 最大值
        int max = Integer.MAX_VALUE;

        //取 int 最小值
        int min = Integer.MIN_VALUE;
        System.out.println("int 类型的最大值为："+max);
        System.out.println("int 类型的最小值为："+min);
        System.out.println();

        System.out.println("最大值 +1："+ (max+1L));
        System.out.println("最小值 -1："+ (min-(long)1));
        System.out.println("最小值 -2："+ (min-(long)2));

    }
}

浮点数

浮点数就是小数，Java 中只要是小数，默认的数据类型就是 double 型数据。
double 也是保存数据范围最广的数据类型。

public class Test_double{
    public static void main(String[] args) {
        //10.2属于小数，所以数据类型属于double
        //num 数据类型直接定义为了 double
        double num = 10.2;
        
        // 2 则是一个整数，运算时会做自动类型转换
        System.out.println(num*2);
    }
}

默认的小数类型是 double，如需使用 float 可进行强制转换。

public class Test_double{
    public static void main(String[] args) {
         float x = 10.2F;
        float y = (float) 10.2;

        System.out.println(x);
        System.out.println(y);
    }
}

字符型

byte 属于字节，一个字符 = 两个字节，对于字符除了与字节有一些关系外，最主要的关系在于与 int 型变量的转换。
在计算机当中，一切都是以编码的形式出现的，Java 使用的是十六进制的 UNICODE 编码，此类编码可以保存任意的文字，但是这个编码在设计的过程中，考虑到与其他语言的结合问题，此编码还包含了 ASCII 码的部分编码。

int 和 char 转换

这里还要插入一点，Java 和 C 语言有相同的 ASCII 编码转换规则。
例如：将 char 字符型 转换为 int 整型
大写字母转换成数字后的区间为 数字 65 ~ 90
而小写字母转换数字后的区间为 数字 97 ~ 122
它们相互之间差了32。

code示例：

public class Test_char {
    public static void main(String[] args) {
        char c = 'A';
        int num = c;
        System.out.println(c); //输出为 A
        System.out.println(num); //输出为 65
    }
}

布尔型

布尔型是一种逻辑结果，主要保存 true、false 两类数据。该类数据主要用于一些程序的逻辑使用。

public class Test_boolean {
    public static void main(String[] args) {
        boolean flag = false; //布尔类型只有两种值：false、true
        if (!flag){ //判断结果值是否为 true，为true执行。
            System.out.println("Hello_World!");
        }
    }
}

boolean 型的默认值为 false，在许多编程语言中，有许多用数字来表示值。
0：false，1：true

布尔型数据在大多数情况下都是用于逻辑控制的，而 if 分支结构也是操作逻辑控制的重要选择之一。
在 if 分支结构中，执行结果判断为 true，则表示执行相应语句。如果为 false 则表示不执行。

String 型数据

与其他几种类型相比，String属于引用数据类型（它属于一个类，Java中的类名称都是以大写字母命名开头规范）
String 表示的是一个字符串，多个字符的集合。String 要求使用双引号声明其内容。

public class Test_string {
    public static void main(String[] args) {
        String str = "兔C";  //字符串变量
        System.out.println(str); //输出字符串变量
        System.out.println("Hello_World!"); //输出字符串常量
    }
}

字符串的连接

public class Test_string {
    public static void main(String[] args) {
        String str = "Hello";
        str = str + "World";
        str +="!!!";
        System.out.println(str);
    }
}

注！当运算符 + 和字符串变量一起拼接时，要用(括号)来改变变量值之间计算的优先级。

转义符

Java 中也支持多种转义字符的使用。
例如：换行符\n 、制表符\t 、\ ( \ \ )、双引号( \ ")、单引号( \ ’ )…

String str = "Hello\"World\" \n\tHello 兔C";
System.out.println(str);

4. 运算符

Java 中的语句有多种形式，表达式就是其中之一。表达式由操作数与运算符组成，操作数可以是常量，变量可以是方法，而运算符就是数学中的运算符号。
四则运算：加+ 减- 乘* 除/
取模%

下面我们将运算符进行分类，分别介绍：

关系运算符

关系运算符的主要功能是进行数据的大小关系比较，返回的结果是 boolean 型数据。常用的关系运算符有 大于、大于等于、小于、小于等于、等于、不等于。

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));

猜猜结果吧…

数学运算符

数学运算符：四则运算、求模、自增等…

int numA = 10;
int numB = 20;
System.out.println("加法计算："+(numA + numB));
System.out.println("减法计算："+(numA - numB));
System.out.println("乘法计算："+(numA * numB));
System.out.println("除法计算："+(numA /(double)numB));

模 % 是数学中余数的概念。

取个余数，看一下：11 除以 5 吧

System.out.println(11 % 5);

看一下，余数是不是 1…

简化运算符

Java 提供了四则运算符，为简化用户的编写，运算符中又提供了一些简化运算符：*= 、 /= 、+= 、-= 、 %=

int num = 10;

System.out.println("乘等计算："+ (num*=2)); // 运算结果为 20

自增自减的单独介绍

++ 自增、-- 自减
根据位置不同，执行的顺序也不同。
++变量，--变量：写在前面表示的是先进行变量内容的自增 1 或 自减1，再使用变量进行数学计算；
变量++，变量--： 写在后面表示先进行变量值的计算，而后在实现自增或自减的操作。

自增自减在前

int numA = 10;
int numB = 20;

int result = ++numA + numB;
System.out.println(result); //31

自增自减在后

int numA = 10;
int numB = 20;

int result = (numA++) +numB;
System.out.println(result);//30

三目运算符

三目是一种赋值运算的形式，执行三目时可以以一个布尔表达式的结果进行赋值。

//语法：
数据类型 变量名 = 布尔表达式?满足此条件时设置的内容:不满足表达式时设置的内容;

public class TestDemo{
	public static void main(String[] args){
		int numA = 50;
        int numB = 20; //定义两个变量，存入数值

		//利用三目运算符进行判断 变量 numA 是否大于 numB,
		//大于 将 numA的值赋值给 max，反之 numB的值赋值给 变量max
        int max = numA > numB?numA : numB;
        System.out.println(max); //输出max的值：50
	}
}

逻辑运算符

逻辑运算一共包含3种：与（多个条件一起满足）、或（多个条件有一个满足）、非（使用 “!”操作，可以实现 true 变 false 以及 false 变 true的结果转换）。

!非运算符

非运算符一般针对于布尔结果进行求反。

boolean flag = false;
System.out.println(!flag); //输出为true

与操作

与操作表示将若干个条件一起进行判断，同时满足返回 true，有一个不满足就返回 false。
与操作符有两种，&（普通与）、&&（短路与）。

//普通与&
int num =10;
if((num == 9) & (num % 5 == 0)){
	System.out.println("num变量存储的整数值是一个常量："+num);
}

该输出为空，
因为普通与在进行逻辑运算时，计算出第一个条件值的结果返回为 false 后，
即便后续的条件值结果返回为了 true，其最终结果也是 false。
只有返回值都为 true，才会为 true。

//短路与&&
int num =10;
if((num == 10) && (num % 5 == 1)){
	System.out.println("num变量存储的整数值是一个常量："+num);
	//依然没有输出任何内容
}

短路与在进行逻辑运算时，当第一个条件值的结果返回为 false 后，出现短路，
最终结果就为 false。
若第一个条件值的结果返回为 true，后续继续执行。
只有条件值结果都返回为 true，其结果才会返回为 true。

或操作

或操作是若干个条件一起判断，其中有一个返回 true，结果就是 true。只有都返回为 false 时，接过才为 false。
或操作的两种运算符：| 和 ||

// 普通或|
int num = 10;
if ((num == 1) | (num / 0 ==0)){
	System.out.println("Hello World");
}

这段代码在运行后出现报错：java.lang.ArithmeticException！
第一个条件值的结果一定返回为 false，第二个条件值运行时出现报错，说明即便是第一个条件值判断为 false 后面的条件也一定继续进行判断。
而使用 普通或 进行逻辑运算时，有一个条件值出现为 true，其结果就为 true。

// 短路或||
if ((1 == 1 ) || ( 10 / 0 ==0)){
	System.out.println("Hello World"); //输出为 HelloWorld！
}

短路或在逻辑运算中，第一个条件值返回为 true，后面不再进行判断，
其结果就为 true。

位运算符

位运算符在 Java 中有：&、|、^、~、>>、>>、>>>。而所有的位运算符都是采用二进制数据进行操作的。

十进制转换二进制：

十进制转换为二进制的原则：数据除以2取余，随后倒着排序。Java 的int 数据类型为 32位。数位上没有数值补0。

5. 程序逻辑控制

程序逻辑控制一般分为三种：顺序结构、选择结构、循环结构。

顺序结构

程序至上而下执行，一条语句执行完后继续执行下一条语句，一直到程序的末尾。

选择结构

选择分支结构是根据条件的成立与否，再决定要执行语句的一种结构。

---

if 语句

语法：

if(布尔表达式){
	//条件满足时执行的程序;
}

执行流程：

使用示例：

int score = 90;
if(score>60){
	System.out.println("分数及格...");
}

---

if…else 语句

语法：

if(布尔表达式){
	//条件满足时执行的程序;
}else{
	//条件不满足时程序的程序;
}

执行流程：

使用示例：

int score = 50;
if (score > 60){
	System.out.println("分数及格...");
}else {
	System.out.println("分数不及格！！");
}

---

if…else if…else 语句

语法：

if(布尔表达式1){
	//条件满足时程序的程序;
}else if(布尔表达式2){
	//条件满足时程序的程序;
}else{
	//所有条件都不满足时程序的程序;
}

执行流程：

使用示例：

double score = 90.5;

if (score >= 90 && score <= 100){
	System.out.println("成绩分数优异...");
}else if (score >= 80 && score <= 90){
	System.out.println("成绩分数良好...");
}else if (score >= 70 && score <= 80){
	System.out.println("成绩分数中等...");
}else {
	System.out.println("成绩分数较差...");
}

---

循环结构

循环结构是根据判断条件的成立与否，决定程序段落的执行次数。

switch

语法：

switch(整数|字符|枚举|String){
	case 内容:{
		内容满足时执行;
		break;
	}
	case 内容:{
		内容满足时执行;
		break;
	}
	case 内容:{
		内容满足时执行;
		break;
	}
	default :{
		内容不满足时执行;
		break;
	}
}

执行流程：

使用示例：

int ch =4;
switch (ch){
	case 1:
		System.out.println("内容是1");
		break;
	case 2:
		System.out.println("内容是2");
		break;
	case 3:
		System.out.println("内容是3");
		break;
	default:
		System.out.println("没有匹配到内容...");
		break;
}

break 的作用

上个示例中，每一个 case 语句后都加上了一个 “break”语句。如不加上此语句，switch在执行时会从第一个满足条件的 case 语句开始依次执行后续的设置。

如： case1 满足条件，后续的 case 都会执行。或 case1 未满足条件，会将 下一个满足条件的 case 和后续case全部执行。

---

当某段代码需要一直重复执行时，可以使用循环结构来实现控制。

while 循环

1. 先判断后执行的 while

语法：

while(循环判断){
	//循环语句;
	//修改循环结束条件
}

执行流程：

使用示例：

//实现累加 1 ~ 100 的累加
int sum =0;
int current =1;
while (current <= 100){
	sum += current;
	current++;
}

System.out.println("sum的值是："+sum);

2. 先执行后判断的 do…while

语法：

do{
	//循环语句;
	//修改循环结束条件;
}while(循环判断);

执行流程：

使用示例：

int sum = 0;
int current =1;
do {
	sum += current;
	current++;
}while (current <= 100);
System.out.println("sum的值是："+sum);

---

for 循环

语法：

for(循环初始条件;循环判断;循环条件变更){
	//循环语句;	
}

执行流程：

使用示例：

//实现 1 ~ 100 的累加
int sum =0;
for(int i =1; i <= 100; i++){
	sum += i;
}
System.out.println("sum的值是："+sum);

---

循环的选用场景

while循环：在不确定循环次数，但是确定循环结束条件的情况下使用；
for 循环：确定循环次数的情况下使用。

for 循环的嵌套使用

利用for循环的嵌套使用打印九九乘法口诀表

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

对循环的控制

正常情况下只要执行了循环，且满足循环条件，循环体内的代码就会一直执行，但是在程序中也提供有两个循环停止的控制语句。

continue：

for (int i = 0; i < 10; i++) {
	if (i == 3){
		continue;
	}
	System.out.print("i = "+i+"、"+"\t");
}

continue 语句的作用是结束当前次循环

break

for (int i = 0; i < 10; i++) {
	if (i == 3){
		break;
	}
	System.out.print("i = "+i+"、"+"\t");
}

break 语句的作用是结束整个循环。

6. 方法的定义和使用

方法在很多地方又称之为函数(在Java中的英文单词是 Method，而在其他语言中的因为单词是 Function)，方法是一段可以被重复调用的代码。

方法的基本概念

方法的主要功能是封装可以执行的一段代码，这样不仅可以进行重复调用，更可以方便地实现代码的维护。

语法：

public static 返回值类型 方法名称(参数类型 参数变量, ...){
	//方法体(此方法要执行的若干操作);
	return 返回值;
}

返回值类型指该方法的返回结果。
返回值类型：
1. 基本数据类型、引用数据类型。设置返回值必须使用 return 进行值的返回值。
2. 方法没有返回值 void，可以不使用 return 返回内容，
	但是可以使用 return 结束方法调用。 

使用示例：

无返回值的方法

public class TestMethod {
    public static void main(String[] args) {
        printInfo();
    }

    public static void printInfo(){
        System.out.println("HelloWorld!");
    }
}

! 定义类名称时采用大驼峰，定义方法名称时采用小驼峰。

有参数无返回值的方法

public class TestMethod {
    public static void main(String[] args) {
        pay(20);
    }

    public static void pay(double money){
        if (money > 0.0){
            System.out.println("可进行支付....");
        }else {
            System.out.println("账户额度不足....");
        }
    }
}

有参数有返回值的方法

public class TestMethod {
    public static void main(String[] args) {
        int sum = add(10 , 5);
        System.out.println("计算后的和是："+sum);
        System.out.println(add(10,5)); // 方法有返回值，可直接输出
    }

    public static int add(int x, int y){
        return x+y;
    }
}

利用 reutrn结束方法调用

public class TestMethod {
    public static void main(String[] args) {
        set(10);
        set(3);
        set(30);
    }

    public static void set(int x){
        if (x == 3){
        // 参数等于3时，结束该方法。
            return;
        }
        System.out.println(x);
    }
}

方法的重载

方法重载指：方法的名称相同，参数类型或个数不同。

使用示例：

public class TestMethod {
    public static void main(String[] args) {
        System.out.println(add(10,20));
        System.out.println(add(10,20,30));
        System.out.println(add(10.2,30.3));
    }

    public static int add(int x,int y){
        return x+y;
    }

    public static int add(int x,int y,int z){
        return x+y+z;
    }

    public static double add(double x, double y){
        return x+y;
    }
}

方法的重载根据参数类型及个数来进行区分，而不是依靠返回值的不同来确定！

方法的递归调用

递归调用是一种特殊的调用方式，指的是方法自己调用自己的形式。

递归需满足以下两个条件：

1. 必须有结束条件
2. 每次调用时都需要改变传递的参数。

示例code：

//使用递归实现 1 ~ 100 的累加
public class TestMethod {
    public static void main(String[] args) {
        System.out.println(sum(100));
    }

    public static int sum(int num){
        if (num == 1){
            return 1;
        }
        return num + sum(num -1);
    }
}