第一部分：基础程序设计

第一章：计算机、程序和JAVA概述

1.1 什么是计算机

计算机是存储和处理数据的电子设备，包括硬件和软件两个部分。

中央处理器：CPU由控制单元和算数运算单元组成。
比特和字节：一个字节等于8个比特，字节是最小的存储单元。
内存：RAM
存储设备：有硬盘、光盘（CD）和USB闪存存储器。
输入和输出设备：键盘、鼠标、显示器。
通信设备：

1.2 什么是软件开发

软件定义：按照特定顺序组织的计算机数据和指令的集合，也就是计算机程序。
软件分类：系统软件和应用软件。
软件开发：

1.3 什么是计算机语言

人类语言
机器语言：二进制形式的一套内嵌的原子指令集，例如10010100101。
汇编语言：低级语言，使用短的描述性单词来表示每一条机器语言指令，例如add表示数字相加。
高级语言：高级语言中的指令称作语句，用高级语言编写的程序称为源程序或者源代码。由于计算机不能运行源程序，源程序必须被翻译成可执行的机器代码。翻译可以由另外一种称为解释器或者编译器的编程工具来完成。<1>解释器从源代码中读取一条语句，将其翻译成机器代码或者虚拟机代码，然后立刻运行，如图a所示。请注意来自源代码的一条语句可能被翻译成多条机器指令.<2>编译器将整个源代码翻译成机器代码文件，然后执行该机器代码文件，如图b所示。

在这里插入图片描述

1.4 什么是Java语言

Java语言简介：Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等
Java三大体系：<1>Java标准版(Java Standard Edition)可以用来开发客户端的应用程序。应用程序可以独立运行或者作为applet在Web浏览器中运行。<2>Java企业版(Java Enterprise Edition)可以用来开发服务器端的应用程序。<3>Java微型版(Java Micro Edition)用来开发移动设备的应用程序，例如手机。
JRE：Java运行时环境，它的全称是Java Runtime Environment。它是运行Java程序的必需条件。
JDK:全称是Jave SE Development Kit，即Java标准版开发包，它提供了编译、运行Java程序所需的各种工具和资源，包括Java编译器、Java运行时环境，以及常用的Java类库等。
JVM：Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。这就是Java的能够“一次编译，到处运行”的原因。
注意：如果需要开发java程序，则应该选择安装JDK；当然，安装了JDK之后，就包含了JRE，也可以运行java程序。但如果只是运行java程序，则需要在计算机上装JRE，仅安装JVM是不够的。
Java创始人之一：詹姆斯.高斯林
Eclipse配置
环境变量配置

1.5 编写并运行Java程序

示例：HelloWorld

public class HelloWorld {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		System.out.println("java语言入门很简单，\n明白了吗");
	}
}

1.6 程序设计风格

正确的注释和注释风格：常用的注释有 // 单行注释 /* */是多行注释
正确的缩进和空白：
块的风格：块风格是由花括号围起来的一组语句。块的写法有两种常用格式,次行风格和行尾风格

1.7 程序设计错误

语法错误：在编译过程中出现的错误称为语法错误或编译错误。语法错误是由创建代码时的错误引起的，例如：拼错关键字，忽略了一些必要的标点符号，或者左花括号没有对应的右花括号。这些错误通常很容易检测到，因为编译器会告诉你这些错误在哪儿，以及是什么原因造成的。
运行时错误：是引起程序非正常中断的错误。运行应用程序时，当环境检测到一个不可能执行的操作时，就会出现运行时错误。输入错误是典型的运行时错误，当程序等待用户输入一个值，而用户输入了一个程序不能处理的值时，就会发生输入错误。例如，如果程序希望读入的是一个数值，而用户输入的却是一个字符串，就会导致程序出现数据类型错误。另一个常见的运行时错误是0作除数。当整数除法中除数为0时可能引发这种情况。例如下面这种情况，如下图所示：
逻辑错误：当程序没有按照预期的方式执行时就会发生逻辑错误。例如你想要得到的结果是97，而结果得到的却是63。语法错误和运行时错误往往很容易寻找，因为编译器会提示，而逻辑错误很难找。
遗漏括号
遗漏分号
遗漏引号
命名拼写错误：Java大小写是很敏感的。编程入门者往往容易犯这种错误，比如将main写成Main，将int写成INT等等。

本章小结

计算机是存储和处理数据的电子设备。
计算机包括硬件和软件。
硬件是计算机中可以触摸到的物理部分。
计算机程序，也就是通常所说的软件，是一些不可见的指令，他们控制硬件完成任务。
计算机程序设计就是编写让计算机执行的指令(即代码)。
中央处理器(CPU)是计算机的大脑。它从内存获取指令并且执行这些指令。
一个比特(bit)是二进制数0或1.
一个字节(byte)是指8比特的序列。
千字节大约是1000字节，兆字节大约是100万字节，千兆字节大约是10亿字节，万兆字节大约是一万亿字节。
内存存储CPU要执行的数据和程序指令。
内存单元是字节的有序序列。
内存是不能长久保存数据的，因为断电时信息就会丢失。
程序和数据永久的存储在设备里，当计算机确实需要使用他们时被移到内存。
机器语言是一套内嵌在每台计算机的原始指令集。
汇编语言是一种低级程序设计语言，它用助记符表示每一条机器语言的指令。
高级语言类似英语，易于学习和编写程序。
用高级语言编写的程序称为源程序
编译器是将源程序翻译成机器语言程序的软件。
操作系统（OS）是管理和控制计算机的活动的程序。
Java是平台无关的，这意味着只需编写一次程序，就可以在任何计算机上运行。
Java程序可以内嵌在HTML网页内，通过Web浏览器下载，给Web客户带来生动的动画和灵活的交互性。
Java源程序文件名必须和程序中的公共类名一致，并且以扩展名.java结束。
每个类都被编译成一个独立字节码文件，该文件名与类名相同，扩展名为.class。
使用Javac命令可以从命令行编译Java源代码文件。使用Java命令可以从命令行运行Java类。
每个Java程序都是一套类的定义集合。关键字class引入类的定义，类的内容包含在块内。
一个块以花括号{开始，以右花括号}结束。
方法包含在类中。每个可执行的Java程序必须有一个main方法。main方法是程序开始执行的入口。
Java中的每条语句都是以分号（；）结束的。也称该符号为语句结束符号，保留字也称关键字，对编译器而言都有特殊意义，在程序中不能用于其他目的。
Java源程序是区分大小写的。
编译错误分为三大类：语法错误（编译错误），运行时错误和逻辑错误。
运行时错误指引起程序非正常结束的错误。当一个程序没有按照预期的方式执行时，产生逻辑错误。

编程练习题

public class Demo {
/*
 *  double v=s/t;
 *  总英里double s=14/1.6;
 *  double t=(45*60+30)/3600;
 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
         double s,t;
         System.out.println("平均速速为"+(14/1.6)*(3600.0/(45*60+30)));
	}
}

第2章基本程序设计

2.1 关键字和标识符

关键字：Java语言中有一些具有特殊用途的单词被称为关键字（keyword），当定义标识符时，不要让标识符和关键字相同。否则将引起错误。例如，下面代码将无法通过编译。java的所有关键字都是小写的，TRUE,FALSE,NULL都不是Java关键字。

public class CeShi {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
          int boolean;//bolean是一个标识符 不能定义为变量名称
	}
}

Java关键字
在这里插入图片描述

标识符：标识符就是用于给程序中变量、类、方法命名的符号。Java语言的标识符必须是以字母、下划线（_）、美元符（$）开头，后面可以跟任意数目的字母、数字、下划线和美元符。此处的数字并不局限于26个英文字母，而且可以包含中文字符、日文字符等等。
使用标识符时，需要注意如下规则。
（1）标识符不能以数字打头。
（2）标识符不能是Java关键字和保留字，但可以包含关键字和保留字。
（3）标识符不能包含空格。
（4）标识符只能包含上述几种符号。

2.2 注释和常量

注释：
常量：命名常量是一个代表不变值得标识符。π是一个常量，但是如果频繁的使用它，但是右不想重复的输入3.1415926，代替的方法就是声明一个常量π，语法如下：

final double PI=3.1415926;

进制：

在这里插入图片描述

2.3 变量和数据类型

变量：编程的本质，就是对内存中数据的访问和修改。程序所用的数据都会保存在内存中，程序员需要一种机制机制来访问或者修改内存中的数据。这种机制就是变量，每个变量都代表了一小块内存，而且变量是有名字的，程序对变量赋值，实际上就是把数据装入该变量所代表的内存的过程；程序读取变量的值，实际上就是从该变量所代表的的内存去取值的过程。形象的理解：变量相当于一个有名称的容器，该容器用于装各种不同类型的数据。
数据类型：Java是强类型语言，包含两个方面的含义（1）所有的变量必须先声明后使用（2）指定类型的变量只能接受类型与之匹配的值。
Java语言支持的类型分为两类：基本类型和引用类型。
1. 基本数据类型包括boolean型和数值类型，数值类型有整数类型和浮点类型。整数类型包括byte、short、int、long、char,浮点类型包括float和double。***char代表字符型，实际上字符型也是一种整数类型，相当于无符号整数类型。
2. 引用类型包括类、接口、和数组类型，还有一种特殊null类型。字符串是一个类，也就是一个引用数据类型。

2.5 数据类型转换

数据类型转换

2.6算数运算符

加 +
减 -
乘 *
除 /
取余 %
自加 ++
自减 –
示例：显示当前时间

public class CeShi {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
         long zhm=System.currentTimeMillis();
         long zm=zhm/1000;
         long zfz=zm/60;
         long zxs=zfz/60;
         System.out.println("现在是"+(zxs%24+8)+"时"+zfz%60+"分"+zm%60+"秒");
	}
}

示例：整钱兑零

import java.util.Scanner;

public class Demo2_2 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入总钱数:");
		int  money=(int)(sc.nextDouble()*100);//11
		//money=money*100;
		int  dollar=money/100;
		money=money%100;
		int  quater=money/25;
		money=money%25;
		int  dime=money/10;
		money=money%10;
		int  nickel=money/5;
		int  penny=money%5;
		System.out.println("dollar="+dollar);
		System.out.println("quater="+quater);
		System.out.println("dime="+dime);
		System.out.println("nickel="+nickel);
		System.out.println("penny="+penny);

	}

}

2.7 赋值运算符

加等 +=
减等 -=
乘等 *=
除等 /=
模等 %=

2.8 位运算符

位与 &：左边假右边不计算。
位或 |：左边真右边不计算
位异或 ^
位左移 <<
位右移 >>

2.9 常见错误和陷阱

未声明、未初始化的变量和未使用的变量
整数溢出
取整错误
超出预期的整数除法
冗余的输入对象

本章小结

标识符是程序中用于命名诸如变量、常量、方法和类、包之类元素的名称。
标识符的要求是什么。
变量是用于存储数据的程序。声明变量就是告诉编译器变量可以存储何种数据类型。
有两种类型的import语句：明确导入和通配符导入，也就是说前者是导入需要的类而后者是将包中所有的类导入。
在java中，等号（=）用作赋值运算符。
方法中声明必须在使用前被赋值。
命名常量表示从不改变的永久数据。
用关键字final声明命名常量。
java提供4种整数类型。
java提供两种浮点型，float和double。
当计算的表达式中有不同类型的值，java会自动的将操作数转换为恰当的类型。
将一个较小范围类型的变量转换为较大范围类型的变量称为拓宽类型，反之为缩窄类型。
拓宽类型不需要强制转换，可以自动完成，缩窄类必须显式完成。
在计算机科学中1970年1月1日午夜零点称为UNIX时间戳。

编程练习题

2.1
在这里插入图片描述

public class CeShi {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
         Scanner sc=new Scanner(System.in);
         System.out.println("请输入要存的钱");
         double money=sc.nextDouble();
         System.out.println("请输入要存入几个月");
         int month=sc.nextInt();
         double allmoney=0;
        for(int yue=1;yue<=month;yue++) {
        	allmoney=(allmoney+money)*(1+0.00417);
        }
        System.out.println(month+"月后的钱是"+allmoney+"元");
	}
}

2.2
在这里插入图片描述

import java.util.Scanner;

public class CeShi {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入三角形三个点的坐标");
        double x1=sc.nextDouble();
        double y1=sc.nextDouble();
        double x2=sc.nextDouble();
        double y2=sc.nextDouble();
        double x3=sc.nextDouble();
        double y3=sc.nextDouble();
        double bian1=Math.sqrt(Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2));
        double bian2=Math.sqrt(Math.pow(x2-x3, 2)+Math.pow(y2-y3, 2));
        double bian3=Math.sqrt(Math.pow(x3-x1, 2)+Math.pow(y3-y1, 2));
        double s=(bian1+bian2+bian3)/2;
        double area=Math.pow(s*(s-bian1)*(s-bian2)*(s-bian3), 0.5);
        System.out.println("面积为"+area);
	}
}

第三章选择语句

3.1 比较运算符

大于 >
大于等于 >=
小于 <
小于等于 <=
等与 ==
不等于！=

3.2逻辑运算符

单与 &
双与&&
或 |
双或 ||
非！
异或 ^

3.3 if语句

单if
if-else分支
多if-else嵌套
多if-else
示例：计算身体质量指数

import java.util.Scanner;


public class Test1 {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		//1.获取身高和体重
		System.out.print("Please enter your weight and hight:");
		double weight=scanner.nextDouble();
		double hight=scanner.nextDouble();
		//2.BMI=体重/身高^2
		double BMI=weight/hight/hight;
		//3.将BMI进行判断，输出相应的说明
		if(BMI>=30.0){
			System.out.println("过胖");
		}else if(BMI>=25.0){
			System.out.println("超重");
		}else if(BMI>=18.5){
			System.out.println("正常");
		}else{
			System.out.println("偏瘦");
		}
	}
}

示例：判断闰年

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
           Scanner sc=new Scanner(System.in);
           System.out.println("请输入年份");
           int year=sc.nextInt();
           if(year%4==0&&year%100!=0||year%400==0) {
        	   System.out.println("闰年");
           }else {
        	   System.out.println("土年");
           }
		}
	}

示例：彩票

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
           Scanner sc=new Scanner(System.in);
          int random=(int)(Math.random()*100);//假设为           28
          //System.out.println(random);
          System.out.println("请输入一个数字！");
          int num=sc.nextInt();
          System.out.println("电脑产生的数字是"+random);
          //输入                          17
          //定义a1为输入的个位数字 b1位十位数字
          //定义a2为随机产生的个位数字 b2为十位数字
          /*
           * if(a1==a2&&b1==b2)   10000
           * if(a1==b2&&b1==a2)   3000
           * if(a1==a2||a1==b2||b1==a2||b1==b2)
           */
          int a1=num%10;
          num/=10;
          int b1=num%10;
          int a2=random%10;
          random/=10;
          int b2=random%10;
          if(a1==a2&&b1==b2) {
        	  System.out.println("一等奖10000元！");
          }else if(a1==b2&&b1==a2){
        	  System.out.println("二等奖3000元！");
          }else if(a1==b2||a2==b1||a2==a1||b1==b2){
        	  System.out.println("三等奖1000元");
          }else {
        	  System.out.println("拜拜！");
          }
		}
	}

3.4 switch语句

switch
不带case的switch
switch语句遵循下面的规则：

在这里插入图片描述

3.5 条件表达式

布尔表达式

3.6常见错误和陷阱

忘记必要的括号
在if行出现的分号
对布尔值得冗余测试
悬空else出现的歧义
两个浮点值的相等测试
简化布尔变量赋值
避免不同情形中的重复代码

本章小结

boolean类型变量可以存储值true或者false
关系操作符（<,<=,==,!=,>,>=）产生一个布尔值。
选择语句用于可选择的动作路径的编程。选择语句有以下几种类型：单分支if语句、双分支if-else语句、嵌套if语句、多分支if-else语句、switch语句和条件表达式。
各种if语句都是基于布尔表达式来控制决定。根据表达式的值时true或false，这些语句选择两种可能中的一种。
布尔操作符&&、||、！和^对布尔值和布尔变量进行计算。
当对p1&&p2求值时，java先求p1的值，如果p1为true,再对p2求值。如果p1为false，就不再对p2求值。当对p1||p2求值时，先对p1求值，如果p1为false，再对p2求值，如果p1位true就不再对p2求值。
switch语句根据char、byte、int、short或者String类型的Switch来进行控制决定。
在switch语句中，关键字break是可选的，但它通常在每个分支的结尾，以中止switch的语句的剩余部分。如果没有出现break语句，则执行接下来的case语句。
表达式中的操作符按照括号、操作符优先级以及操作符结合规则所确定的次序进行求值。
括号用于强制求值的顺序以任何顺序进行。
具有更高级优先权的操作符更早的进行操作。对于同样优先级的操作符，它们的结合规则确定操作的顺序。
除了赋值运算符的所有二元操作符都是左结合的，赋值运算符号是右结合的。

编程练习题

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
           Scanner sc=new Scanner(System.in);
           System.out.println("请输入a、b、c的值");
           double a=sc.nextDouble();
           double b=sc.nextDouble();
           double c=sc.nextDouble();
           double delt=b*b-4*a*c;
           if(delt>=0) {
        	   if(delt>0) {
        		   System.out.println("有两个解");
        		   System.out.println((-b+Math.sqrt(delt))/2*a+"和"+(-b-Math.sqrt(delt))/2*a);
        	   }else {
        		   System.out.println(-b/2*a);
        	   }
           }else {
        	   System.out.println("无解");
           }
		}
	}

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入代表今天日期的数字");
		int today = sc.nextInt();
		System.out.println("请输入今天之后的天数");
		int sinceday = sc.nextInt();
		int willday = (today + sinceday) % 7;
		switch (willday) {
		case 0:
			System.out.println("周日");
			break;
		case 1:
			System.out.println("周一");
			break;
		case 2:
			System.out.println("周二");
			break;
		case 3:
			System.out.println("周三");
			break;
		case 4:
			System.out.println("周四");
			break;
		case 5:
			System.out.println("周五");
			break;
		case 6:
			System.out.println("周六");
			break;
		default:
			break;
		}
	}
}

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		int random = (int) (Math.random() * 3);
		System.out.println("电脑产生的是" + random);
		System.out.println("请输入0、1或者2");// 依次代表石头、剪刀、布
		int in = sc.nextInt();
		if (in == 0) {
			if (random == 0) {
				System.out.println("平局");
			} else if (random == 1) {
				System.out.println("玩家赢");
			} else {
				System.out.println("电脑赢");
			}
		}
		if (in == 1) {
			if (random == 1) {
				System.out.println("平局");
			} else if (random == 2) {
				System.out.println("玩家赢");
			} else {
				System.out.println("电脑赢");
			}
		}
		if (in == 2) {
			if (random == 2) {
				System.out.println("平局");
			} else if (random == 1) {
				System.out.println("玩家赢");
			} else {
				System.out.println("电脑赢");
			}
		}

	}
}

在这里插入图片描述

提示：一月和二月在这个公式里是用13和14表示的。所以需要将用户输入的月份1转换为13，将用户输入的2转换为14，同时年份改为前一年。

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner scanner=new Scanner(System.in);
		//1.获取 年份 月 日
		System.out.print("Enter year:");
		int year=scanner.nextInt();
		System.out.print("Enter month:");
		int month=scanner.nextInt();
		System.out.print("Enter the day of the month:");
		int day=scanner.nextInt();
		//隐含计算 j 世纪数 k该世纪的第几年
		if(month==1||month==2){
			month+=12;
			year--;
		}
		int j=year/100;
		int k=year%100;
		int h=(day+26*(month+1)/10+k+k/4+j/4+5*j)%7;
		System.out.println(h);
		switch (h) {
		case 0:
			System.out.println("星期六");
			break;
		case 1:
			System.out.println("星期天");
			break;
		case 2:
			System.out.println("星期一");
			break;
		case 3:
			System.out.println("星期二");
			break;
		case 4:
			System.out.println("星期三");
			break;
		case 5:
			System.out.println("星期四");
			break;
		case 6:
			System.out.println("星期五");
			break;
		default:
			break;
		}
	}
}

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入这个点的x坐标");
		double x = sc.nextDouble();
		System.out.println("请输入这个点的x坐标");
		double y = sc.nextDouble();
		if (x <= 200 && x >= 0) {
			if ((200 - x) / y >= 2) {
				System.out.println("点在三角形里面");
				return;
			} else {
				System.out.println("点在三角形外面");
			}
		}
	}
}

在这里插入图片描述

思路

import java.util.Scanner;
public class Demo4_3 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
       Scanner sc=new Scanner(System.in);
       System.out.println("请输入第一个矩形的中心点坐标和宽高");
       double x1=sc.nextDouble();
       double y1=sc.nextDouble();
    	double w1=sc.nextDouble();
    	double h1=sc.nextDouble();
    	System.out.println("请输入第二个矩形的中心点坐标和宽高");
    	double x2=sc.nextDouble();
        double y2=sc.nextDouble();
     	double w2=sc.nextDouble();
     	double h2=sc.nextDouble();
     	if(x2<=(w1/2-w2/2)+x1&&x2>=x1-(w1/2-w2/2)&&y2<=(h1/2-h2/2)+y1&&y2>=y1-(h1/2-h2/2)) {
     		System.out.println("第二个在第一个内");
     	}else if(x2>=(w1/2+w2/2)+x1||x2<=(x1-w1/2-w2/2)||y2>=(h1/2+h2/2)+y1||y2<=(y1-w1/2-w2/2)) {
     		System.out.println("第二个在第一个外");
     	}else {
     		System.out.println("重叠");
     	}
	}
}

第四章循环语句

4.1 while循环

while语句：
示例：猜数字

import java.util.*;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int random = (int) (Math.random() * 101);
		while (true) {
			System.out.println("请输入一个数字");
			int n = sc.nextInt();
			if (n > random) {
				System.out.println("输入的值太大，重新输入");

			} else if (n < random) {
				System.out.println("太小，请重新输入");
			} else {
				System.out.println("相同");
				break;
			}
		}
	}
}

4.2 do-while循环

do-while语句：
示例:用do-while语句猜数字

import java.util.Scanner;

public class Test4_1dowhile {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		int number = (int) (Math.random() * 101);
		int num = 0;
		do {
			System.out.println("请输入你的猜测");
			num = sc.nextInt();
			if (num > number) {
				System.out.println("输入的值过大");
			} else if (num < number) {
				System.out.println("输入的值太小");
			}
		} while (num != number);

		System.out.println("对了，电脑产生的数是" + number);

	}

}

4.3for循环

for语句：
for嵌套语句：
示例：最大公约数

import java.util.*;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入n");
		int n=sc.nextInt();
		System.out.println("请输入m");
		int m=sc.nextInt();
		int min=n>m?m:n;
		int temp=1;
        for(int k=min;k>=1;k--) {
        	if(n%k==0&&m%k==0) {
        		System.out.println("这个数是"+k);
        		break;
        	}
        }
	}
}

示例：预测未来学费

import java.util.Scanner;

public class Test4_2xuefe {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc=new Scanner(System.in);
		
		int year=0;
		double xuefei=10000;
		while(xuefei<20000) {
			xuefei*=1.07;
			year++;
		}
		System.out.println("第"+year+"年的学费是10000的两倍");
	}
}

在这里插入图片描述

import java.util.Scanner;
public class Test4_2zhuanhuan {
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.print("Enter a number:");
		int number=scanner.nextInt();
		String str="";
		while(number!=0){//123 7
			int num=number%16;//11 7
			if(num<10){
				str=num+str;//"7B"      B
			}else{
				switch(num){
					case 10:
						str="A"+str;
						break;
					case 11:
						str="B"+str;
						break;
					case 12:
						str="C"+str;
						break;
					case 13:
						str="D"+str;
						break;
					case 14:
						str="E"+str;
						break;
					case 15:
						str="F"+str;
						break;
				}
			}
			//str B
			number/=16;//7 0
		}
		System.out.println("0X"+str);//7B
	}
}

4.4 嵌套循环

示例：打印直角三角形

import java.util.*;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入n");
		int n = sc.nextInt();
		printf(n);
	}

	private static void printf(int n) {
		// TODO 自动生成的方法存根
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
	}
}

示例：打印菱形
`import java.util.Scanner;

public class haha {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入n”);
int n = sc.nextInt();
printf(n);
}

private static void printf(int n) {
	// TODO 自动生成的方法存根
	for (int i = 1; i <= n; i++) {
		for (int k = 1; k <= Math.abs(i - 5); k++) {
			System.out.print(" ");
		}
		for (int j = 1; j <= i && j + i <= 10; j++) {
			System.out.print("* ");
		}
		System.out.println();
	}
}

}

打印空心菱形`

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入n");
		int n = sc.nextInt();
		printf(n);
	}

	private static void printf(int n) {
		// TODO 自动生成的方法存根
		for(int i=1;i<=n;i++) {
			for(int k=1;k<=Math.abs(i-5);k++) {
				System.out.print(" ");
			}
			for(int j=1;j<=i&&i+j<=10;j++) {
				if(i==j||j==1||i+j==10) {
					System.out.print("* ");
				}else {
					System.out.print("  ");
				}
			}
			System.out.println();
		}
	}
}

4.5 breakh和continue

break语句
continue语句
return语句
示例：判断回文串

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入回文");
		String s = sc.nextLine();
		judge(s);
	}

	private static void judge(String s) {
		// TODO 自动生成的方法存根
		for (int i = 0; i < s.length() / 2; i++) {
			if (s.charAt(i) != s.charAt(s.length() - 1 - i)) {
				System.out.println("不是回文！");
				return;
			}
		}
		System.out.println("是回文");
	}
}

显示素数

public class haha {
	public static void main(String[] args) {
		int count = 0;
		int num = 1;
		while (count <= 50) {
			boolean flag = true;
			for (int i = 2; i <= num / 2; i++) {
				if (num % i == 0) {
					flag = false;
					break;
				}
			}
			if (flag) {
				count++;
				System.out.print(num + " ");
				if (count % 10 == 0) {
					System.out.println();
				}
			}
			num++;
		}
	}
}

本章小结

循环语句有三类：while循环、do-while循环和for循环。
循环中包含重复执行的语句称为循环体。
循环体执行一次称为循环的一次迭代。
无限循环是指循环语句被无限次执行。
在设计循环时，既需要考虑循环控制结构，还需要考虑循环体。
while循环首先检查循环继续条件。如果条件为true，则执行循环体；如果条件为false，则循环结束。
do-while循环和while循环类似，只是do-while先执行循环体，再检查循环继续条件，以确定是否继续。
while和do-while常用于循环次数不确定的情况。
for循环一般用于在循环次数固定的情况。
for循环由三部分组成。第一部分是初始操作，通常用于初始化控制变量。第二部分是循环继续条件，决定是否执行循环体。第三部分是每次迭代后执行的操作，经常用于调整控制变量。通常，在控制结构中初始化和修改循环控制变量。
在循环中可以使用break和continue这两个关键字。
关键字break立即终止包含break 的最内层循环。
关键字continue只是终止当前迭代。

编程练习题

4.1 在这里插入图片描述

import java.util.Scanner;
public class Demo4_1 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
       Scanner sc=new Scanner(System.in);
       int countz=0;
       int countf=0;
       int sum=0;
	while(true) {
    	   System.out.println("请输入整数");
    	   int num=sc.nextInt();
    	   if(num>0) {
    		   countz++;
    	   }else if(num<0) {
    		   countf++;
    	   }else {
    		   break;
    	   }
    	   sum+=num;
       }
	System.out.println("正数为"+countz+"个");
	System.out.println("负数为"+countf+"个");
	System.out.println("总和为"+sum);
	System.out.println("平均数为"+(double)sum/(countz+countf));
		   
	}
}

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int count=0;
		String firstname="";
		String secondname="";
		int firstscore=0;
		int secondscora=0;
		System.out.println("请输入学生的个数");
		int stdnum=sc.nextInt();
		while(count<stdnum) {
			System.out.println("请输入学生的名字和成绩");
			String name=sc.next();
			int score=sc.nextInt();
			if(score>firstscore) {
				secondscora=firstscore;
				secondname=firstname;
				firstscore=score;
				firstname=name;
			}else {
				secondscora=score;
				secondname=name;
			}
			count++;
		}
		System.out.println("最高分"+firstscore+" 姓名"+firstname);
		System.out.println("第二最高分"+secondscora+" 姓名"+secondname);
	}
}

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		int count=0;
		for(int i=100;i<=200;i++) {
			if(i%5==0||i%6==0^i%6==0&&i%5==0) {
				System.out.print(i+" ");
			}
			count++;
			if(count%10==0) {
				System.out.println();
			}
		}
	}
}

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入");
		int num = sc.nextInt();
		while (true) {
			boolean flag=false;
			for (int i = 2; i < num / 2; i++) {
				if (num % i == 0) {
					System.out.print(i + ",");
					num /= i;
					flag=true;
					break;	
				}
			}
			if(!flag) {
				System.out.println(num);
				break;
			}
		}
	}
}

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入");
		int n=sc.nextInt();
		for(int i=1;i<=n;i++) {
			for(int k=1;k<=n-i;k++) {
				System.out.print("  ");
			}
			for(int j=-i;j<=i;j++) {
				if(j!=0&&j!=1) {
					System.out.print(Math.abs(j)+" ");
				}
			}System.out.println();
		}
	}
}

在这里插入图片描述

public class Demo4_8 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
/*
 *       0  1  2  3  2  1  0
 *      -3-2-1   0  1  2  3    j
 *      j+i-1          i-1-j
 */
		for(int i=1;i<=8;i++) {
			for(int k=0;k<8-i;k++) {
				System.out.print("    ");
			}
			for(int j=1-i;j<i;j++) {
				if(j<=0) {
					System.out.printf("%-4d",(int)Math.pow(2, j+i-1));
				}else {
					System.out.printf("%-4d",(int)Math.pow(2, i-1-j));
				}
			}
			System.out.println();
		}
	}
}

在这里插入图片描述

import java.util.Scanner;

public class haha {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入");
		int n=sc.nextInt();
		double pi=4.0;
		int flag=1;
		double sum=0;
		for(int i=1;i<=n;i++) {
              sum+=(flag*1.0)/(2*i-1);
              flag=-flag;
		}
		System.out.println(pi*sum);
	}
}

在这里插入图片描述

import java.util.Scanner;
public class haha {
	public static void main(String[] args) {
		for(int i=1;i<=10000;i++) {
			int sum=0;
			for(int j=1;j<=i/2;j++) {
				if(i%j==0) {
					sum+=j;
				}
			}
			if(i==sum) {
				System.out.print(i+" ");
			}
		}
	}
}

在这里插入图片描述

import java.util.Scanner;
public class haha {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入一个二进制数");
		int number=sc.nextInt();
		String str="";
		/*
		 *10%2=0~5   10/2=5
		 *
		 *5%2=1~2      5/2=2
		 *
		 *2%2=0~1     2/2=1
		 *
		 *1%2=1 ~0   1/2=0
		 *
		 */
		while(true) {
			int a=number%2;  
			str=a+str;//  
			number/=2;
			if(number==0) {
				break;
			}
		}
		System.out.print(str);
	}
}

在这里插入图片描述

import java.util.Scanner;

public class Demo4_19 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc=new Scanner(System.in);
		int a[]=new int[5];
		System.out.println("请输入5个数");
		for(int i=0;i<a.length;i++) {
			a[i]=sc.nextInt();
		}
//		int a[]= {3,5,2,5,5,5,0};
		int max = 0;
		int count = 0;
		for (int i = 0; i < a.length - 1; i++) {
			if (a[i]== 0) {
				break;
			}else {
				max = a[i + 1] > a[i] ? a[i + 1] : a[i];
			}
		}
		for (int i = 0; i < a.length; i++) {
				if (a[i] == max) {
					count++;
				}	
		}
		System.out.println("最大值是" + max);
		System.out.println("最大值出现的次数是" + count);
	}
}

第5章函数

5.1方法定义

修饰符
返回值类型
函数名
参数列表
函数体

5.2 方法调用

函数调用函数
函数递归调用

5.3实际参数和形式参数

实际参数
形式参数
参数传值

5.4 方法重载

方法重载的定义
方法重载的条件
方法重载的注意项

5.5变量的的作用域

局部变量
全局变量

5.6常用的数学函数

三角函数
指数函数
取整函数
min、max和abs方法
random方法
Random类

5.7 String相关函数

求字符串的长度
从字符串中获取字符
连接字符串
字符串的转换

public class Demo5_12 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String str = "123";
		int a = Integer.parseInt(str);
		System.out.println(a);
	}
}

从控制台读取字符串
从控制台读取字符
字符串比较
获取字符串中的字符或子串

本章小结

程序模块化和可重用性是软件工程的中心目标之一。Java提供了很多有助于完成这一目标的有效结构。方法就是这样的一个结构。
方法头指定方法的修饰符、返回值类型、方法名和参数。本章所有的方法都使用静态修饰符static。
参数列表是指方法中参数的类型、次序和数量。方法名和参数列表一起构成方法签名。参数是可选的，也就是说，一个方法可以不包含参数。
return语句也可以用在void方法中，用来终止方法并返回到方法的调用者。在方法中，有时用于改变正常流程控制是很有用的。
传递给方法的实际参数应该与方法签名中的形式参数具有相同的数目、类型和顺序。
方法可以重载。这就意味着两个方法可以拥有相同的方法名，只要他们的方法参数列表不同即可。
在方法中声明的变量称作局部变量。局部变量的作用域是从声明它的地方开始，到包含这个变量的块结束为止。局部变量在使用前必须声明和初始化。
方法抽象是把方法的应用和实现分离。用户可以在不知道方法是如何实现的情况下去使用方法。方法的实现细节封装在方法内，对调用该方法的用户隐藏。这称为信息隐藏或封装。
当实现一个大型程序时，可以使用自顶向下或者自底向上的编码方法。不要一次性编写完整个程序。

编程练习题

在这里插入图片描述

import java.util.Scanner;

public class Demo5_1 {
/*
 * 123%10 3
 * 123/10 12
 * 12%10 2
 * 12/10 1
 * 1%10 0
 * 1/10
 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个整数");
        long n=sc.nextLong();
        System.out.println(sumDigits(n));
	}

	private static int  sumDigits(long n) {
		// TODO 自动生成的方法存根
		int sum=0;
		while(true) {
			sum+=(int) (n%10);
			n/=10;
			if(n/10==0) {
				break;
			}
		}
		return sum;
	}
}

在这里插入图片描述

import java.util.Scanner;

public class Demo5_2 {
	/*
	 * 121 %10 1 121/10 12 12%10 2 2/10 0 0%2 2
	 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个数字");// 121
		int num = sc.nextInt();
		if(isPalindrome(num)) {
			System.out.println("是回文");
		}else {
			System.out.println("不是回文");
		}
	}

	public static int reverse(int number) {
		String str = "";
		int sum = 0;
		while (true) {
			str = str + number % 10;
			number /= 10;
			if (number / 10 == 0) {
				str = str + number;
				break;
			}
		}
		return Integer.parseInt(str);
	}

	public static boolean isPalindrome(int number) {
		return reverse(number) == number;
	}
}

在这里插入图片描述

import java.util.Scanner;

public class Demo5_4 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入三个数");
		double num1 = sc.nextDouble();
		double num2 = sc.nextDouble();
		double num3 = sc.nextDouble();
		diPlaySortNumber(num1, num2, num3);

	}

	private static void diPlaySortNumber(double num1, double num2, double num3) {
		// TODO 自动生成的方法存根
		double temp;
		if (num1 > num2 && num1 > num3) {
			temp = num3;
			num3 = num1;
			num1 = temp;
			if (num1 > num2) {
				temp = num2;
				num2 = num1;
				num1 = temp;
			}
		}
		if (num2 > num1 && num2 > num3) {
			temp = num3;
			num3 = num2;
			num2 = temp;
			if (num1 > num2) {
				temp = num2;
				num2 = num1;
				num1 = temp;
			}
		}
		if (num3 > num2 && num3 > num1) {
			if (num1 > num2) {
				temp = num2;
				num2 = num1;
				num1 = temp;
			}
		}
		System.out.print(num1 + "," + num2 + "," + num3);
	}
}

在这里插入图片描述

public class Demo5_6 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for (double i = 31.0; i <= 40.0; i++) {
			System.out.print(i + ": " + cesiusToFahrenheit(i));
			System.out.println();
		}
	}

	private static double cesiusToFahrenheit(double i) {
		// TODO 自动生成的方法存根
		double Fahrenheit = (9.0 / 5) * i + 32;
		return Fahrenheit;
	}
}

在这里插入图片描述

import java.util.Scanner;

public class Demo5_8 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入n");
		int n = sc.nextInt();
		for (int i = 1; i <= n; i++) {
			System.out.printf("%4d:  %8.4f", i, m(i));
			System.out.println();
		}
	}

	private static double m(int i) {
		// TODO 自动生成的方法存根
		double sum = 0;
		for (int j = 1; j <= i; j++) {
			sum += (j * 1.0) / (j + 1);
		}
		return sum;
	}

}

在这里插入图片描述

import java.util.Scanner;

public class Demo5_9 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		for (int i = 1; i <= 901; i = i + 100) {
			System.out.printf("%4d:%.4f", i, m(i));
			System.out.println();
		}
	}

	private static double m(int i) {
		// TODO 自动生成的方法存根
		double sum = 0.0;
		double flag = 1.0;
		for (int j = 1; j <= i; j++) {
			sum += flag / (2 * j - 1);
			flag = -flag;
		}
		return 4 * sum;
	}

}

在这里插入图片描述

import java.util.Random;
import java.util.Scanner;

public class Demo5_10 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入n");
		int n = sc.nextInt();
		print(n);
	}

	private static void print(int n) {
		// TODO 自动生成的方法存根
		Random random = new Random();
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				System.out.print(random.nextInt(2) + " ");
			}
			System.out.println();
		}
	}
}

在这里插入图片描述

import java.util.Scanner;

public class Demo5_11 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个密码");
		String str = sc.nextLine();
		boolean condition1 = leastContainEight(str);
		boolean condition2 = containNumAndWorld(str);
		boolean condition3 = leasContainTwoNum(str);
		if (condition1 && condition2 && condition3) {
			System.out.println("有效密码");
		} else {
			System.out.println("格式错误");
		}
	}

	private static boolean leasContainTwoNum(String str) {
		// TODO 自动生成的方法存根
		return jisuanNum(str) > 2;
	}

	private static int jisuanNum(String str) {
		// TODO 自动生成的方法存根
		int count = 0;
		for (int i = 0; i < str.length(); i++) {
			char c = str.charAt(i);
			if (isNum(c)) {
				count++;
			}
		}
		return count;
	}

	private static boolean containNumAndWorld(String str) {
		// TODO 自动生成的方法存根
		for (int i = 0; i < str.length(); i++) {
			char c = str.charAt(i);
			if (!(isNum(c) || isWorld(c))) {
				return false;
			}
		}
		return true;
	}

	private static boolean isWorld(char c) {
		// TODO 自动生成的方法存根
		return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
	}

	private static boolean isNum(char c) {
		// TODO 自动生成的方法存根
		return c >= '0' && c <= '9';
	}

	private static boolean leastContainEight(String str) {
		// TODO 自动生成的方法存根
		return str.length() >= 8;
	}
}

在这里插入图片描述

package lianxi;

public class Demo5_20 {
/*
 * 1.计算两个骰子的和
 * 2.如果骰子的和为2、3、12 
 *    lose
 * 3.如果骰子的和为7、11
 *     win
 *   -----第二步和第三步执行一次------
 * 4.如果和为4、5、6、8、9、10
 *         4.1继续
 *         4.2如果和为7  lose
 *         4.3如果和与上次的和相等  win
 *         否则 继续 第四步以后的循环 直到满足条件后退出
 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		boolean flag=true;
		int lastsum=0;
		while(true) {
			int a=(int) (Math.random()*7);
			int b=(int) (Math.random()*7);
			int sum=a+b;
			if(flag) {
				if(sum==2||sum==3||sum==12) {
					System.out.println("你摇的点数和为"+a+"+"+b+"="+sum);
					System.out.println("你输了");
					break;
				}else if(sum==7||sum==11) {
					System.out.println("你摇的点数和为"+a+"+"+b+"="+sum);
					System.out.println("你赢了");
					break;
				}else {
					System.out.println("你摇的值是"+sum+"，不符合输赢规则，请继续！");
					lastsum=sum;
					flag=false;
				}
			}else {
				if(sum==7) {
					System.out.println("你摇的点数和为"+a+"+"+b+"="+sum);
					System.out.println("你输了");
					break;
				}else if(sum==lastsum){
					System.out.println("你摇的点数和为"+a+"+"+b+"="+sum);
					System.out.println("你赢了");
					break;
				}else {
					System.out.println("你摇的值是"+sum+"，不符合输赢规则，请继续！");
					lastsum=sum;
				}
			}	
		}
	}
}

第六章一维数组

6.1 一维数组的定义

数组的定义:数组是用来存储数据的集合，但是，通常我们会发现把数组看做一个存储具有相同类型的变量集合会更有用。一个数组变量看起来似乎是存储了一个数组，但实际上它存储的是指向数组的引用。当创建数组后，它的元素被赋予默认值，数值型基本数据类型的默认值为0。
数组初始化语法中不使用操作符new。使用数组出初始化语法时候，必须将声明、创建和初始化数组都放在一条语句中，将他们分开会发生错误。
数组的内存分析：
访问元素：处理数组的时候经常会用到for循环：
示例：查找数组中最大、最小值和平均值
foreach循环：Java支持一个简便的for循环、称为foreach循环、即不使用下标变量就可以顺序地遍历整个数组。通常foreach循环的语法为：
-
示例：分析数字

6.2数组的复制

自定义复制

import java.util.Arrays;

public class Demo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int a[]= {1,2,3,4,5,6};
		extendArray(a,a.length*2);
	}

	private static void extendArray(int[] oldArray, int newLength) {
		// TODO 自动生成的方法存根
		int[] newArray=new int[newLength];
		for(int i=0;i<Math.min(oldArray.length, newArray.length);i++) {
			newArray[i]=oldArray[i];
		}
		System.out.println(Arrays.toString(newArray));
	}
}

Arrays.copyOf( )

import java.util.Arrays;

public class Demo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int a[]= {1,2,3,4,5,6};
		int b[]=Arrays.copyOf(a, 12);
		System.out.println(Arrays.toString(b));
	}
}

6.3 可变长参数与数组

在这里插入图片描述

import java.util.Arrays;

public class Demo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		bianchangcanshu(1, 2, 3, 4, 5, 6);
	}

	private static void bianchangcanshu(int... number) {
		// TODO 自动生成的方法存根
		if (number.length == 0) {
			System.out.println("没有元素");
			return;
		}
		System.out.println(Arrays.toString(number));
	}
}

第一部分：JavaSe笔记（基础程序设计）

第一部分：基础程序设计

第一章：计算机、程序和JAVA概述

1.1 什么是计算机

1.2 什么是软件开发

1.3 什么是计算机语言

1.4 什么是Java语言

1.5 编写并运行Java程序

1.6 程序设计风格

1.7 程序设计错误

本章小结

编程练习题

第2章 基本程序设计

2.1 关键字和标识符

2.2 注释和常量

2.3 变量和数据类型

2.5 数据类型转换

2.6算数运算符

2.7 赋值运算符

2.8 位运算符

2.9 常见错误和陷阱

本章小结

编程练习题

第三章 选择语句

3.1 比较运算符

3.2逻辑运算符

3.3 if语句

3.4 switch语句

3.5 条件表达式

3.6常见错误和陷阱

本章小结

编程练习题

第四章 循环语句

4.1 while循环

4.2 do-while循环

4.3for循环

4.4 嵌套循环

4.5 breakh和continue

本章小结

编程练习题

第5章 函数

5.1方法定义

5.2 方法调用

5.3实际参数和形式参数

5.4 方法重载

5.5变量的的作用域

5.6常用的数学函数

5.7 String相关函数

本章小结

编程练习题

第六章 一维数组

6.1 一维数组的定义

6.2数组的复制

6.3 可变长参数与数组

6.3数组的查找与排序

6.4 Arrays工具类

本章小结

猜你喜欢

第2章基本程序设计

第三章选择语句

第四章循环语句

第5章函数

第六章一维数组