第一章 / 第二章总结
一:对java的认识
1.认识了java的发展史:java1.1,java1.2,java1.3,java1.4,java5,java6,java7,java8
2.使用了记事本编写代码:
public class Helloworld{
public static void main(String[ ] args){
System.out.println("hello !!");
}
}
且使用了DOC命令:1.输入cmd进入DOC 2.输入cd +桌面路径 3.输入javac +文件名.java 4.输入java +文件名
3.配置环境变量+验证变量是否配置成功+Eclipse的安装
(1)配置环境变量:在我的电脑属性——高级系统设置——环境变量名——创建一个JAVA_HOME变量,变量值填写jdk 安装目录
(2)系统变量→寻找 Path 变量→点击编辑——点击编辑文本在变量之后加上java里bin的安装路径
如;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
(3)验证是否配置成功:
widow+R输入cmd进入doc,输入java -version
javac后
java后
4.安装Eclipse的认识和运用
5.使用了反编译工具Front End plus:
(1)先解压——进入Front End plus界面——File——Decompile class file——选取需反编译的文件——直接生成java文件——file——save source as进行保存即可
6.变量名的命名规则:(1)以字母,下划线,美元符号,人名币符号(开头),后面+数字,骆驼(即字下美人数骆驼);(2)有意义;(3)不能使用关键字
7.java常用的数据类型:
(1) 整型:int…
1:数值: 2:非数值:char(单个字符型) ,boolean(布尔型)String(字符串)
(2)浮点型:double,float
String:不是基本数据类型,是引用数据类型,java提供的一个类
8.变量的声明及使用
(1)声明变量名,根据数据类型在内存申请空间
数据类型 变量名 ; int age;
(2)赋值,即将数据存储至对应的内存空间
变量名=数值; age=18;
(1)(2)步合并:数据类型 变量名=数值; int age=18;
(3)使用变量名,即取出数据使用
public class Demo1{
public static void main(String[ ] args){
String name="小明";
char sex='男';
int age=18;
double score=98.5;
System.out.println("姓名:"+name);
System.out.println("性别:"+sex);
System.out.println("年龄:"+age);
System.out.println("成绩:"+score);
}
}
9.常量
(1)常量名通常大写(常量前加final表示该数为常量,不能加以修改)
(2)不同字符使用下划线加以分隔,(若常量有两个或多个单词组成,下划线分隔并所以字母大写)
(3)只能被赋值一次,通常定义时即对其初始化
public class Mathclass{
public static void main(String[ ] args){
double banjing=1.5;
final double PI=3.14;
double mianji=banjing*banjing*PI;
System.out.println("圆的面积是:"+mianji);
}
}
10.Scanner的使用
(1)导入Scanner类
import java.util.*;
(2)创建Scanner对象
Scanner input=new Scanner(System.in);
(3)获得键盘输入的数据
int now(变量名)=input.nextInt();
注: int now=input.nextInt();
String now=input.next();
double now=input.nextdouble();
import java .util.*;
public class jianli{
public static void main(String[ ] args){
//用户键盘录入
Scanner input=new Scanner(System.in);
//使用input获得字符串
System.out.print("请输入姓名:");
String name=input.next();
System.out.print("请输入性别:");
String sex=input.next();
System.out.print("请输入年龄:");
int age=input.nextInt();
System.out.println("姓名:"+name);
System.out.println("性别:"+sex);
System.out.println("年龄:"+age);
}
}
(11)基本运算符:+,—,*,/(取商),%(取余),++(自加),— —(自减)
注:++,— —:在前,先自加或自减,再进行运算;
++,— —:在前先进行运算,再自加或自减;
public class jianli{
public static void main(String[ ] args){
int num1=9;
int num2=2;
//取商
System.out.print(9/2);
//取余
System.out.print(9%2);
//自加/自减,++/--在前
System.out.print(++num1);//num1=num1+1=10
System.out.print(--num2);//num2=num2-1=1
//++/--在后
System.out.print(num1++);//num1=num1+1=9
System.out.print(num2--);//num2=num2-1=2
}
}
(12)复合算数运算符:+=,-=,*=,/=,%=
public class jianli{
public static void main(String[ ] args){
int num1=9;
int num2=2;
num1+=2;//num1=num1+2=11
num2*=2;//num2=num2*2=4
System.out.println(num1);
System.out.println(num2);
}
}
(12)关系运算符:
运算符 | 含义 | 范例 | 结果 |
---|---|---|---|
== | 等于 | 5==6 | false |
!= | 不等于 | 5!=6 | ture |
> | 大于 | 5>6 | false |
< | 小于 | 5<6 | ture |
>= | 大于等于 | 5>=6 | false |
<= | 小于等于 | 5<=6 | ture |
注:
- =为赋值运算符,==为等于运算符
- 关系表达式的结果为布尔值(ture/false)
(13)逻辑运算符
运算符 | 含义 | 运算规则 |
---|---|---|
&& | 短路与 | 两个操作数为ture,结果才为ture |
| | | 短路或 | 两个操作数中,其一为false,结果才为false |
! | 非 | 操作数为ture,结果为false;操作数为false,结果为ture |
优先级:!>&&>| |
(14)条件运算符
条件 ? 表达式1 : 表达式2 (满足条件即ture,输出表达式1,反之输出表达式2)
public class jianli{
public static void main(String[ ] args){
int min;
min=5<7?10:7;
System.out.println(min);//输出10
min=10<7?8:7;
System.out.println(min);//输出7
}
}
第三章 第四章 总结
一:第三章 总结
-
if语句:
if选择结构是根据条件判断结果选择不同的处理
if(条件){
//代码块
}
public class Scoreavg {
public static void main(String[] args) {
int java=100;
int music=90;
if((java>90&&music>80)||(java==100&&music>70)){
System.out.println("奖励");
}
}
}
2.if else语句
else的条件是默认与if的条件相反
if(条件){
//代码块1
}else(不需要条件){
//代码块2
}
public class Scoredemo {
public static void main(String[] args) {
int java=100;
if((java>90){
System.out.println("奖励");
}else{
System.out.println("惩罚");
}
}
}
3.多重if选择结构适用于:变量处于某个连续区间时
if(条件){
//代码块1
}else if(条件:对上一条件的否定){
//代码块2
}else{
//代码块3
}
public class Scoredemo {
public static void main(String[] args) {
int score=100;
if(score>=80){
System.out.println("良好");
}else if(score>=60){
System.out.println("中等");
}else{
System.out.println("差");
}
}
}
多重if使用时需注意顺序,要么升序,要么降序
4.嵌套if选择结构
嵌套if控制语句可以通过外层语句和内层语的协助增强程序的灵活性
if(条件){
if(){
//代码块1
else{
//代码块2
}
}
}else if(条件:对上一条件的否定){
//代码块2
}else{
//代码块3
}
import java.util.*;
public class Runtext{
public static void main(String[] args){
Scanner input=new Scanner (System.in);
System.out.println("请输入您的跑步成绩:");
int time=input.nextInt();
System.out.println("请输入您性别(男/女):");
String sxe=input.nextInt();
if(time>10){
if(sex.equals("男")){
System.out.println("您进入了男子组决赛");
}else if(sex.equals("男")){
System.out.println("您进入了女子组决赛");
}else{
System.out.println("对不起,您的性别不符合参赛要求");
}
}else{
System.out.println("对不起,成绩不合格,无法进入决赛");
}
}
}
5.switch语句
特点:条件为等值判断
switch(表达式){
case 常量1:
语句:
break;
case 常量2:
语句:
break;
case 常量3:
语句:
break;
defalut:
语句:
break;
}
public calss Compete{
public static void main(String[] args){
int mingci=1;
switch(mingci){
case 1:
System.out.println("参加麻省理工夏令营一个月")
break;
case 2:
System.out.println("奖励苹果手机一部")
break;
case 3:
System.out.println("移动硬盘一个")
break;
default :
System.out.println("不奖励")
break;
}
}
}
以下为循环结构(while;do-while;for)
6.while循环:先判断,后执行;初始情况不满足循环条件时:一次都不执行
while(循环条件){
循环操作
}
import java.util.*;
public class Runtext{
public static void main(String[] args){
Scanner input=new Scanner (System.in);
System.out.println("杨锡昌今天学习是否合格?(y/n):");
String answer=input.next();
while(answer.equals("n")){
System.out.println("上午学习理论");
System.out.println("下午上机练习");
System.out.println("杨锡昌今天学习是否合格?(y/n):");
answer input=next.input();
}
System.out.println("杨锡昌学习达标");
}
}
7.do-while循环:先执行,后判断;初始情况不满足循环条件时:不管任何情况下都至少执行一次
do{
循环操作
}while(循环条件);
import java.util.*;
public class Runtext{
public static void main(String[] args){
Scanner input=new Scanner (System.in);
String answer;
do{
System.out.println("编写程序");
System.out.println("是否合格(Y/n)");
answer=input.next();
}while(answer.equals("n"));
System.out.println("杨锡昌学习合格");
}
}
8.for循环:若循环次数可以判断的出,优先考虑使用for
注意:for循环中定义的变量,循环之外不能使用
for循环的语法和执行顺序
for (1步.表达式1(可省略);2步.5步.表达式2(可省略);4步.表达式3(可省略)){
=for (参数初始化);(条件判断为布尔值);(更新循环变量)
3步.循环操作
}
import java.util.*;
public class Runtext{
public static void main(String[] args){
Scanner input=new Scanner (System.in);
System.out.println("请输入学生成绩:");
String name=input.next();
double avg=0;
double sum=0;
for(int i=1;i<=5;i++){
System.out.println("请输入第"+i+"成绩:");
double score=input.nextDouble();
sum=sum+score;
}
avg=sum/5;
System.out.println("5门的平均成绩是:"+avg);
}
}
9.总结循环语句的区别与适用情况
while do-while for的区别
1.语法不同
a.while与for:先判断,再执行
b.do-while:先执行,再判断
2.使用情况
a.循环次数确定的情况,通常选用for循环
b.循环次数不确定的情况,通常选用while或do-while循环
10.跳转语句
1.break语句语法:改变程序控制流,用于while do-while for循环语句中,可跳出当前循环而执行循环后面的语句,通常在循环中与条件语句一起使用
2.continue语句语法:只能在循环中使用,跳过循环体中剩余的语句而执行该循环中的下一次循环,通常与条件语句一起使用,加速循环
if(int i;i<total;i++){
system.out.println("请输入第"+(i+1)+"个人的成绩");
double score=input.nextDouble();
if(score<=80){
continue;
}
}
3.return语句语法:结束当前方法的执行并退出,返回到调用该方法的语句处(面向对象中使用)
11:程序调试:
1.设置断点:程序暂停执行的代码行 2.单步运行F6 3.观察变量
二.第四章 总结
1.数组:数组是一个变量,存储相同数据类型的一组数据
2.声明一个数组就是在内存空间划出一串连续的空间
3.数组的基本组成元素:
a.标识符 b.数组元素 C.元素下标(从0开始) d.元素类型
4.使用数组
a.声明数组:int[ ] a; b.分配空间:a=new int[5];
c.赋值:a[0]=8; d.使用数据:a[0]=a*10;
即:数据类型[ ] 数组名=new 数据类型[长度];
数组元素根据数据类型不同,有不同的初始值:
int[ ] score=new int[5];int[5]的初始值为:5个0
double[ ] score=new double[5];double[5]的初始值为:5个0.0
String[ ] score=new String[5];String[5]的初始值为:5个null
import java.util.*;
public class ClassAvg{
public static void main(String[] args){
Scanner input=new Scanner (System.in);
double[] scores=new double[3];
double sum=0;
for(int i=0;i<score.length;i++){
System.out.println("请输入"+(i+1)+"位学生成绩:");
scores[i]=input.nextDouble();
sum+=score[i];
}
double avg=sum/score.length;
system.out.println("平均分是:"+avg);
}
}
5.增强型for或foreach
语法:
for(int score: scores){
for(数组的数据类型 变量名:数组名)
sum+=score;
}
import java.util.*;
public class ClassAvg{
public static void main(String[] args){
Scanner input=new Scanner (System.in);
double[] scores=new double[3];
double sum=0;
for(int i=0;i<score.length;i++){
System.out.println("请输入"+(i+1)+"位学生成绩:");
scores[i]=input.nextDouble();
}
for(double score:scores){//把scores的每一个数赋值给score
sum+=scores;
}
double avg=sum/score.length;
system.out.println("平均分是:"+avg);
}
}
6.吃货联盟定餐系统
package Project;
import java.util.Scanner;
public class Item_one {
public static void main(String[] args) {
// 数据主体,一组订单信息
String[] names = new String[6];// 订餐人
String[] dishMegs = new String[6];// 所订餐品信息
int[] times = new int[6];// 送餐时间
String[] addresses = new String[6];// 送餐地址
int[] states = new int[6];// 订单状态 0:已预定 1:已完成
double[] sumPrices = new double[6];// 总金额
// 初始化两条订单信息
names[0] = "杨锡昌";
dishMegs[0] = "红烧带鱼2份";
times[0] = 12;
addresses[0] = "深圳市福田区";
states[0] = 0;
sumPrices[0] = 76.0;
// 初始化第二条信息
names[1] = "杨锡昌";
dishMegs[1] = "鱼香茄子2份";
times[1] = 12;
addresses[1] = "深圳市福田区";
states[1] = 1;
sumPrices[1] = 45.0;
// 数据主体,一组餐品信息
String[] dishNames = { "红烧带鱼", "鱼香茄子", "时令蔬菜" }; // 菜品名称
double[] prices = new double[] { 38.0, 20.0, 10.0 }; // 菜品单价
int[] praiseNums = new int[3]; // 点赞数
// 二.整体框架
Scanner input = new Scanner(System.in);
int num = -1; // 用户输入0时返回主菜单,否则退出系统
boolean isExit = false; // 标志用户是否退出系统
System.out.println("\n欢迎使用“吃货联盟订餐系统”");
// 循环:显示菜单,根据用户选择相应的数字执行相应的功能
do {
// 显示菜单
System.out.println("******************");
System.out.println("1.我要订餐");
System.out.println("2.查看餐袋");
System.out.println("3.签收订单");
System.out.println("4.删除订单");
System.out.println("5.我要点赞");
System.out.println("6.退出系统");
System.out.println("******************");
System.out.print("请选择:");
int choose = input.nextInt(); // 记录用户选择的功能编号
// 根据用户输入的功能编号,执行相应的功能
// 1
switch (choose) {
case 1:
// 我要订餐
System.out.println("***我要订餐***");
boolean isAdd = false; // 记录是否可以订餐
for (int j = 0; j < names.length; j++) {
if (names[j] == null) {// 找到第一个空位置,可以添加订单信息
isAdd = true; // 置标志位,可以订餐
System.out.print("请输入订餐人姓名:");
String name = input.next();
// 显示供选择的菜品信息
System.out.println("序号" + "\t" + "菜名" + "\t" + "单价" + "\t" + "点赞数");
for (int i = 0; i < dishNames.length; i++) {
String price = prices[i] + "元";
String priaiseNum = (praiseNums[i]) > 0 ? praiseNums[i] + "赞" : "0";
System.out.println((i + 1) + "\t" + dishNames[i] + "\t" + price + "\t" + priaiseNum);
}
// 用户点菜
System.out.print("请选择您要点的菜品编号:");
int chooseDish = input.nextInt();
System.out.print("请选择您要的份数:");
int number = input.nextInt();
String dishMeg = dishNames[chooseDish - 1] + "" + number + "份";
double sumPrice = prices[chooseDish - 1] * number;
// 餐费满50元,免送餐费5元
double deliCharge = (sumPrice >= 50) ? 0 : 5;
System.out.print("请输入送餐时间(送餐时间是10点至20点间整点送餐):");
int time = input.nextInt();
while (time < 10 || time > 20) {
System.out.print("您输入有误,请输入10-20间的整数!");
time = input.nextInt();
}
System.out.print("请输入送餐地址:");
String address = input.next();
// 无需添加状态,默认是0,即以预定状态
System.out.println("订餐成功!");
System.out.println("您订的是:" + dishMeg);
System.out.println("送餐时间:" + time + "点");
System.out.println("餐费:" + sumPrice + "元" + "送餐费" + deliCharge + "元,总计:" + (sumPrice + deliCharge) + "元");
// 添加数据
names[j] = name;
dishMegs[j] = dishMeg;
times[j] = time;
addresses[j] = address;
sumPrices[j] = sumPrice + deliCharge;
break;
}
}
if (!isAdd) {
System.out.println("对不起,您的餐袋已满!");
}
break;
case 2:
// 查看餐袋
System.out.println("***查看餐袋***");
System.out.println("序号\t订餐人\t餐品信息\t\t送餐时间\t送餐地址\t\t总金额\t订单状态");
for (int i = 0; i < names.length; i++) {
if (names[i] != null) {
String state = (states[i] == 0) ? "已预定" : "已完成";
String date = times[i] + "点";
String sumPrice = sumPrices[i] + "元";
System.out.println((i + 1) + "\t" + names[i] + "\t" + dishMegs[i] + "\t\t" + date + "\t"
+ addresses[i] + "\t" + sumPrice + "\t" + state);
}
}
break;
case 3:
// 签收订单
System.out.println("***签收订单***");
boolean isSignFind = false;// 找到要签收的订单
System.out.print("请选择要签收的订单序号:");
int signOrderId = input.nextInt();
for (int i = 0; i < names.length; i++) {
// 状态为已预定,序号为用户输入的订单序号减1:可签收
// 状态为已完成,序号为用户输入的订单序号减1:不可签收
if (names[i] != null && states[i] == 0 && signOrderId == i + 1) {
states[i] = 1;// 将状态值置为已完成
System.out.println("订单签收成功!");
isSignFind = true;// 标记已找到此订单
} else if (names[i] != null && states[i] == 1 && signOrderId == i + 1) {
System.out.println("您选择的订单已完成签收,不能再次签收!");
isSignFind = true;// 标记已找到此订单
}
}
// 未找到的订单序号:不可签收
if (!isSignFind) {
System.out.println("您选择的订单不存在!");
}
break;
case 4:
// 删除订单
System.out.println("***删除订单***");
boolean isDelFind = false;// 标记是否找到要删除的订单
System.out.print("请选择要删除的订单讯号:");
int delId = input.nextInt();
for (int i = 0; i < names.length; i++) {
// 状态值为已完成,序号值为用户输入的序号减1:可删除
// 状态值为已预定,序号值为用户输入的序号减1:不可删除
if (names[i] != null && states[i] == 1 && delId == i + 1) {
isDelFind = true;// 标记已找到此订单
// 执行删除操作:删除位置后的元素依次前移
for (int j = delId - 1; j < names.length - 1; j++) {
names[j] = names[j + 1];
dishMegs[j] = dishMegs[j + 1];
times[j] = times[j + 1];
addresses[j] = addresses[j + 1];
states[j] = states[j + 1];
sumPrices[j] = sumPrices[j + 1];
}
// 最后一位清空
int endIndex = names.length - 1;
names[endIndex] = null;
dishMegs[endIndex] = null;
times[endIndex] = 0;
addresses[endIndex] = null;
states[endIndex] = 0;
sumPrices[endIndex] = 0;
System.out.println("删除订单成功!");
break;
} else if (names[i] != null && states[i] == 0 && delId == i + 1) {
System.out.println("你选择的订单未签收,不能删除!");
isDelFind = true;// 标记已找到此订单
break;
}
}
// 未找到该序号的订单:不能删除
if (!isDelFind) {
System.out.println("您要删除的订单不存在!");
}
break;
case 5:
// 我要点赞
System.out.println("***我要点赞***");
System.out.println("序号" + "\t" + "菜名" + "\t" + "单价");
for (int i = 0; i < dishNames.length; i++) {
String price = prices[i] + "元";
String priaiseNum = (praiseNums[i] > 0 ? praiseNums[i] + "赞" : "");
System.out.println((i + 1) + "\t" + dishNames[i] + "\t" + price + "\t" + priaiseNum);
}
System.out.print("请选择您要点赞的菜品序号:");
int priaiseNum = input.nextInt();
praiseNums[priaiseNum - 1]++;// 点赞数加1
System.out.println("点赞成功!");
break;
case 6:
// 退出系统
System.out.println("***退出系统***");
System.out.println("谢谢使用!欢迎下次光临!");
break;
default:
// 退出系统
isExit = true;
break;
}
if (!isExit) {
System.out.print("输入0返回:");
num = input.nextInt();
} else {
break;
}
} while (num == 0);
}
}
第五章第六章总结
1.第五章
package Project;
import java.util.Scanner;
public class Item_one {
public static void main(String[] args) {
// 数据主体,一组订单信息
String[] names = new String[6];// 订餐人
String[] dishMegs = new String[6];// 所订餐品信息
int[] times = new int[6];// 送餐时间
String[] addresses = new String[6];// 送餐地址
int[] states = new int[6];// 订单状态 0:已预定 1:已完成
double[] sumPrices = new double[6];// 总金额
// 初始化两条订单信息
names[0] = "杨锡昌";
dishMegs[0] = "红烧带鱼2份";
times[0] = 12;
addresses[0] = "深圳市福田区";
states[0] = 0;
sumPrices[0] = 76.0;
// 初始化第二条信息
names[1] = "杨锡昌";
dishMegs[1] = "鱼香茄子2份";
times[1] = 12;
addresses[1] = "深圳市福田区";
states[1] = 1;
sumPrices[1] = 45.0;
// 数据主体,一组餐品信息
String[] dishNames = { "红烧带鱼", "鱼香茄子", "时令蔬菜" }; // 菜品名称
double[] prices = new double[] { 38.0, 20.0, 10.0 }; // 菜品单价
int[] praiseNums = new int[3]; // 点赞数
// 二.整体框架
Scanner input = new Scanner(System.in);
int num = -1; // 用户输入0时返回主菜单,否则退出系统
boolean isExit = false; // 标志用户是否退出系统
System.out.println("\n欢迎使用“吃货联盟订餐系统”");
// 循环:显示菜单,根据用户选择相应的数字执行相应的功能
do {
// 显示菜单
System.out.println("******************");
System.out.println("1.我要订餐");
System.out.println("2.查看餐袋");
System.out.println("3.签收订单");
System.out.println("4.删除订单");
System.out.println("5.我要点赞");
System.out.println("6.退出系统");
System.out.println("******************");
System.out.print("请选择:");
int choose = input.nextInt(); // 记录用户选择的功能编号
// 根据用户输入的功能编号,执行相应的功能
// 1
switch (choose) {
case 1:
// 我要订餐
System.out.println("***我要订餐***");
boolean isAdd = false; // 记录是否可以订餐
for (int j = 0; j < names.length; j++) {
if (names[j] == null) {// 找到第一个空位置,可以添加订单信息
isAdd = true; // 置标志位,可以订餐
System.out.print("请输入订餐人姓名:");
String name = input.next();
// 显示供选择的菜品信息
System.out.println("序号" + "\t" + "菜名" + "\t" + "单价" + "\t" + "点赞数");
for (int i = 0; i < dishNames.length; i++) {
String price = prices[i] + "元";
String priaiseNum = (praiseNums[i]) > 0 ? praiseNums[i] + "赞" : "0";
System.out.println((i + 1) + "\t" + dishNames[i] + "\t" + price + "\t" + priaiseNum);
}
// 用户点菜
System.out.print("请选择您要点的菜品编号:");
int chooseDish = input.nextInt();
System.out.print("请选择您要的份数:");
int number = input.nextInt();
String dishMeg = dishNames[chooseDish - 1] + "" + number + "份";
double sumPrice = prices[chooseDish - 1] * number;
// 餐费满50元,免送餐费5元
double deliCharge = (sumPrice >= 50) ? 0 : 5;
System.out.print("请输入送餐时间(送餐时间是10点至20点间整点送餐):");
int time = input.nextInt();
while (time < 10 || time > 20) {
System.out.print("您输入有误,请输入10-20间的整数!");
time = input.nextInt();
}
System.out.print("请输入送餐地址:");
String address = input.next();
// 无需添加状态,默认是0,即以预定状态
System.out.println("订餐成功!");
System.out.println("您订的是:" + dishMeg);
System.out.println("送餐时间:" + time + "点");
System.out.println("餐费:" + sumPrice + "元" + "送餐费" + deliCharge + "元,总计:" + (sumPrice + deliCharge) + "元");
// 添加数据
names[j] = name;
dishMegs[j] = dishMeg;
times[j] = time;
addresses[j] = address;
sumPrices[j] = sumPrice + deliCharge;
break;
}
}
if (!isAdd) {
System.out.println("对不起,您的餐袋已满!");
}
break;
case 2:
// 查看餐袋
System.out.println("***查看餐袋***");
System.out.println("序号\t订餐人\t餐品信息\t\t送餐时间\t送餐地址\t\t总金额\t订单状态");
for (int i = 0; i < names.length; i++) {
if (names[i] != null) {
String state = (states[i] == 0) ? "已预定" : "已完成";
String date = times[i] + "点";
String sumPrice = sumPrices[i] + "元";
System.out.println((i + 1) + "\t" + names[i] + "\t" + dishMegs[i] + "\t\t" + date + "\t"
+ addresses[i] + "\t" + sumPrice + "\t" + state);
}
}
break;
case 3:
// 签收订单
System.out.println("***签收订单***");
boolean isSignFind = false;// 找到要签收的订单
System.out.print("请选择要签收的订单序号:");
int signOrderId = input.nextInt();
for (int i = 0; i < names.length; i++) {
// 状态为已预定,序号为用户输入的订单序号减1:可签收
// 状态为已完成,序号为用户输入的订单序号减1:不可签收
if (names[i] != null && states[i] == 0 && signOrderId == i + 1) {
states[i] = 1;// 将状态值置为已完成
System.out.println("订单签收成功!");
isSignFind = true;// 标记已找到此订单
} else if (names[i] != null && states[i] == 1 && signOrderId == i + 1) {
System.out.println("您选择的订单已完成签收,不能再次签收!");
isSignFind = true;// 标记已找到此订单
}
}
// 未找到的订单序号:不可签收
if (!isSignFind) {
System.out.println("您选择的订单不存在!");
}
break;
case 4:
// 删除订单
System.out.println("***删除订单***");
boolean isDelFind = false;// 标记是否找到要删除的订单
System.out.print("请选择要删除的订单讯号:");
int delId = input.nextInt();
for (int i = 0; i < names.length; i++) {
// 状态值为已完成,序号值为用户输入的序号减1:可删除
// 状态值为已预定,序号值为用户输入的序号减1:不可删除
if (names[i] != null && states[i] == 1 && delId == i + 1) {
isDelFind = true;// 标记已找到此订单
// 执行删除操作:删除位置后的元素依次前移
for (int j = delId - 1; j < names.length - 1; j++) {
names[j] = names[j + 1];
dishMegs[j] = dishMegs[j + 1];
times[j] = times[j + 1];
addresses[j] = addresses[j + 1];
states[j] = states[j + 1];
sumPrices[j] = sumPrices[j + 1];
}
// 最后一位清空
int endIndex = names.length - 1;
names[endIndex] = null;
dishMegs[endIndex] = null;
times[endIndex] = 0;
addresses[endIndex] = null;
states[endIndex] = 0;
sumPrices[endIndex] = 0;
System.out.println("删除订单成功!");
break;
} else if (names[i] != null && states[i] == 0 && delId == i + 1) {
System.out.println("你选择的订单未签收,不能删除!");
isDelFind = true;// 标记已找到此订单
break;
}
}
// 未找到该序号的订单:不能删除
if (!isDelFind) {
System.out.println("您要删除的订单不存在!");
}
break;
case 5:
// 我要点赞
System.out.println("***我要点赞***");
System.out.println("序号" + "\t" + "菜名" + "\t" + "单价");
for (int i = 0; i < dishNames.length; i++) {
String price = prices[i] + "元";
String priaiseNum = (praiseNums[i] > 0 ? praiseNums[i] + "赞" : "");
System.out.println((i + 1) + "\t" + dishNames[i] + "\t" + price + "\t" + priaiseNum);
}
System.out.print("请选择您要点赞的菜品序号:");
int priaiseNum = input.nextInt();
praiseNums[priaiseNum - 1]++;// 点赞数加1
System.out.println("点赞成功!");
break;
case 6:
// 退出系统
System.out.println("***退出系统***");
System.out.println("谢谢使用!欢迎下次光临!");
break;
default:
// 退出系统
isExit = true;
break;
}
if (!isExit) {
System.out.print("输入0返回:");
num = input.nextInt();
} else {
break;
}
} while (num == 0);
}
}
第六章总结
1.面向对象基础
对象的特征(属性)
属性:对象具有的各种特征,每个对象的每个属性都拥有特定值
2.对象的行为(方法)
对象:用来描述客观事物的一个实体,由一组属性和方法构成
3.类
具有相同属性和方法的一组对象的集合;类是对象的抽象,对象是类的具体
4.语法
public class 类名{
成员变量 //定义属性
属性1…
属性n
成员方法 //定义方法
方法1…
方法m
}
5.定义类的步骤
1.定义类名 2.编写类的属性 3.编写类的方法
package yuxiwork;
//人类:自定义的数据类型
public class ren {
//属性(特征):成员变量
//姓名 年龄 性别
String name;
int age;
char sex;
//方法(行为):成员方法
//自我介绍
public String showInfo(){
String info="我叫"+name+"\t"+age+"岁"+"\t性别:"+sex;
return info;
}
}
6.类图
Ren |
---|
+name:String |
+age:int |
+sex:char |
+show Info():String |
7.创建和使用对象
1.创建对象
类名 对象名=new 类名();
School center=new School();
2.引用对象成员:使用"."进行操作
a引用类的属性:对象名.属性
center.name=“张三”;
b引用类的方法:对象名.方法名()
center.showCenter();
package yuxiwork;
//人类:自定义的数据类型
public class ren {
//属性(特征):成员变量
//姓名 年龄 性别
String name;
int age;
char sex;
//方法(行为):成员方法
//自我介绍
public String showInfo(){
String info="我叫"+name+"\t"+age+"岁"+"\t性别:"+sex;
return info;
}
}
package yuxiwork2;
//测试人类,创建人类对象
public class Testren {
public static void main(String[] args) {
//创建对象 类名 对象名=new 类名;
ren ren1=new ren();//引用类时,名字需对的上才能调用
//使用对象的属性和方法:对象名.属性 对象名.方法();
ren1.age=18;
ren1.name="张三";
ren1.sex='女';
String s=ren1.showInfo();
System.out.println(s);
}
}
8.方法的返回值
两种情况
1.如果方法具有返回值,方法中必须使用关键字return返回该值,返回值类型为该值的类型,返回值只有一个
2.如果方法没有返回值,即返回类型为void
public class Student{
String name="张三";
public String getName(){
return name;
}
}
9.方法调用
不同类方法调用,需要先创建对象,后使用"."调用,同类则直接使用,直接写方法名即可
1.Student类的方法a()调用Student类的方法b(),直接调用
public void a(){
b();//调用b()
}
2.Student类的方法a()调用Teacher类的方法b(),先创建类对象,然后使用"."调用
public void a(){
Teacher t=new Teacher();
t.b();//调用Teacher类的b()
}
10.例:一个景区根据游人的年龄不同收取不同的票价,编写游人类
package yuxiwork2;
//游人类
public class Visitor {
//创建类属性
String name;
int age;
//创建类方法;根据游客的年龄计算门票费
public void showPrice() {
if(age<10) {
System.out.println("门票免费!");
}else if(age<60) {
System.out.println("门票全费!20元");
}else {
System.out.println("门票半价!10元");
}
}
}
package yuxiwork2;
import java.util.Scanner;
//测试类,实现景区收费功能
public class TestVisitor {
public static void main(String[] args) {
String answer="";
Scanner input =new Scanner (System.in);
do {
//引用对象成员:对象名.属性
Visitor v=new Visitor();
System.out.print("请输入姓名:");
v.name=input.next(); //让类方法接受用户输入的姓名
System.out.print("请输入年龄:");
v.age=input.nextInt();
//引用对象成员:对象名.方法
v.showPrice();
System.out.print("是否继续(y/n)?:");
answer=input.next ();
}while(answer.equals("y"));
System.out.println("程序退出!");
}
}
11.带参方法(在不带参无法实现相对应条件时使用)
12.方法传参
package yuxiwork2;
//一组的为Test.java;Ceshi.java
public class Student {
int age;
}
package yuxiwork2;
//一组的为Ceshi.java;Student.java
public class Test {
//参数int,基本数据类型
public void calc1(int num) {
num=num+1;
}
//参数:自定义数据类型 数组 接口,引用数据类型
public void calc2(Student student) {
student.age=student.age+1;
}
}
package yuxiwork2;
//一组的为Test.java;Student.java
public class Ceshi {
public static void main(String[] args) {
Test test=new Test();
int n=8;
test.calc1(n);
Student stu=new Student();
stu.age=18;
test.calc2(stu);
System.out.println(n+"---"+stu.age);
//当参数传递为基本数据类型时,参数的变化不保留,基本数据类型传值
//当参数传递为引用数据类型(自定义类,数组,接口,String)时,参数的变化会保留,引用数据类型传址
}
}
13.使用学员对象数组作为参数,实现学员成绩修改;如果学员成绩小于60分,集体提高2分
package yuxiwork2;
//学生类
public class Student2 {
// 属性:姓名 成绩
String name;
int score;
//无参构造方法
//(1)该方法缺少返回值 (2)该方法名字必须和类名一样
//每个类都有一个默认的无参构造方法,但是一旦手动添加了有参构造方法,那么系统默认的无参构造方法就会被覆盖掉,若想使用,则需显示的写出来
public Student2() {}
public Student2(String name,int score) {
//this是当前对象
this.name=name;
this.score=score;
}
// 方法:显示个人成绩信息
public void showInfo() {
System.out.println(name + "的成绩是:" + score);
}
}
package yuxiwork2;
//修改成绩
public class ModifyScore {
//遍历学员信息,发现如果有一个学生成绩小于60,则该学生加2分
public void modifyScore(Student2[] stus) {
for(int i=0;i<stus.length;i++) {
if(stus[i].score<60) {
stus[i].score+=2;
}
}
}
//输出学员信息
public void showInfo(Student2[] stus) {
for(Student2 stu:stus) {
stu.showInfo();
}
}
public static void main(String[] args) {
ModifyScore ms=new ModifyScore();
Student2[] stus=new Student2[3];
// Student2 s1=new Student2();
// s1.name="张三";
// s1.score=40;
Student2 s1=new Student2("张三",40);//Student2里的this指的就是这里的s1
// Student2 s2=new Student2();
// s2.name="李四";
// s2.score=90;
Student2 s2=new Student2("李四",90);//Student2里的this指的就是这里的s2
// Student2 s3=new Student2();
// s3.name="王五";
// s3.score=50;
Student2 s3=new Student2("王五",50);//一句顶上面三句//Student2里的this指的就是这里的s3
stus[0]=s1;
stus[1]=s2;
stus[2]=s3;
ms.modifyScore(stus);
ms.showInfo(stus);
}
}
14.构造方法
1.构造方法缺少返回值 2.该方法名字必须和类名一样
15.方法重载
一个类中允许出现多个同名但不同参数的方法,这种方法叫方法重载
第七八章总结
一.第七章总结
1.封装:将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供方法来实现对隐藏信息的操作和访问(保护类中成员)
2.封装的两大原则:
(1)把 尽可能多的东西藏起来,对外提供便捷的接口
(2)把所有的属性藏起来
3.实现封装:
(1)把属性设为private,防止错误的修改
(2)创建共有的getter/setter方法,用于属性的读写
(3)在getter/setter方法中加入属性控制语句,set方法中添加逻辑判断(非必须),对属性值的合法性进行判断
4.包
(1)命名规范
a包名由小写字母组成,不能以圆点开头或结尾
b包名之前最好加上前缀,通常使用组织倒置的网络域名
c包名后续部分依不同机构内部的规范不同而不同:package net.javagroup.reserch.powerproject
5.访问权限控制
(1)类成员访问控制修饰符:1.public 2.protected 3.默认的 4.private
修饰符/作用域 | 同一个类中 | 同一个包中 | 子类中 | 任何地方 |
---|---|---|---|---|
private | 可以 | 不可以 | 不可以 | 不可以 |
默认 | 可以 | 可以 | 不可以 | 不可以 |
protected | 可以 | 可以 | 可以 | 不可以 |
public | 可以 | 可以 | 可以 | 可以 |
static 非static 属性 静态变量 成员变量,实例变量 方法 静态方法,被调用的时候才执行 成员方法,实例方法,被调用的时候才执行 属性加载顺序 类加载的时候会执行一次(只会执行一次) 调用构造方法的时候就重新执行一次 范围 修饰静态变量,静态方法,静态代码块(从上往下加载) -------------------------------- 所属 属于类 属于对象,或属性实例 方法中对属性的访问 只能访问静态变量 可以访问成员变量,也可以访问静态变量 方法中对方法的访问 静态方法中不能调用实例方法 实例方法中可以调用静态方法/成员方法 调用问题 类名调用(推荐),对象调用(不推荐) 对象调用
static | 非static | |
---|---|---|
属性 | 静态变量 | 成员变量,实例变量 |
方法 | 静态方法,被调用的时候才执行 | 成员方法,实例方法,被调用的时候才执行 |
属性加载顺序 | 类加载的时候会执行一次(只会执行一次)累积 | 调用构造方法的时候就重新执行一次 |
范围 | 修饰静态变量,静态方法,静态代码块(从上往下加载) | 修饰静态变量,静态方法,静态代码块(从上往下加载) |
所属 | 属于类 | 属于对象,或属性实例 |
方法中对属性的访问 | 只能访问静态变量 | 可以访问成员变量,也可以访问静态变量 |
方法中对方法的访问 | 静态方法中不能调用实例方法 | 实例方法中可以调用静态方法/成员方法 |
调用问题 | 类名调用(推荐),对象调用(不推荐) | 对象调用 |
tihs/super的使用 | 不能使用this/super | 都可用 |
7.static关键字的作用:
(1)能被类的所有实例共享,可作为实例之间进行交流的共享数据
(2)如果类的所有实例都包含一个相同的常量属性,可把这个属性定义为静态常量类型,从而节省内存空间
8.继承:
1.为什么有继承:简化代码
2.子类继承父类的哪些成员:
(a)继承public和protected修饰的属性和方法,不管子类和父类是否在一个包了
(b)继承默认权限修饰符修饰的属性和方法,但子类和父类必须在同一个包里
3.子类不能继承父类的哪些成员:
(a)private成员
(b)使用默认修饰符修饰的成员,子类和父类不在同一个包里
(c)构造方法
4.super关键字的作用:
调用父类属性,调用父类方法,调用父类构造方法(3条原则:)
(1)调用父类构造方法3条原则:
a.使用super关键字,super代表父类对象
b.在子类构造方法中调用且必须是第一句
c.不可以访问父类中定义为private的属性和方法
5.子类调用父类的构造方法执行顺序:
1.子类通过super关键字显示调用,执行父类中指定的构造方法
2.子类没有通过super关键字,执行父类中默认的无参构造方法
3.子类构造方法调用其它同类中的构造方法,遵循以上两点规律
9.super 与 this的区别
区别 | this | super |
---|---|---|
访问属性 | 访问本类属性;如果没有则从父类找 | 访问父类中的属性 |
访问方法 | 访问本类方法;如果没有则从父类找 | 访问父类中的方法 |
访问构造 | 调用本类构造,放在构造方法首行 | 调用父类构造,放在子类构造方法首行 |
10.单根继承
(1)java只支持单根继承
(2)一个类只能有一个直接父类
(3)一个类可以有多个间接父类
11.方法重写规则:
- 方法名相同
- 参数列表相同
- 返回值类型相同或是其子类
- 访问权限不能严于父类
- 父类的静态方法不能被子类覆盖为非静态方法;父类的非静态方法不能被子类覆盖为静态方法
- 子类可以定义与父类同名的静态方法,以便在子类中隐藏父类的静态方法(注:静态方法中无法使用super)
- 父类的私有方法不能被子类覆盖
- 不能抛出比父类方法更多的异常
12.方法重载与方法重写比较
位置 方法名 方法返回值 参数列表 访问修饰符 方法重载 同类 相同 无关 不同 无关 方法重写 子类 相同 相同/子类 相同 不能严于父级
位置 | 方法名 | 方法返回值 | 参数列表 | 访问修饰符 | |
---|---|---|---|---|---|
方法重载 | 同类 | 相同 | 无关 | 不同 | 无关 |
方法重写 | 子类 | 相同 | 相同/子类 | 相同 | 不能缩小被重写方法的访问权限 |
13.Object 类:object类被子类经常重写的方法
方法 | 说明 |
---|---|
toString() | 返回当前对象本身的有关信息,按字符串对象返回 |
equals() | 比较两个对象是否是同一个对象,是则返回true |
hash code() | 返回该对象的哈希代码值 |
get class() | 获取当前对象所属的类信息,返回class对象 |
14.多态:
-
核心作用:功能扩展,耦合性低
-
定义:条件不同,结果不同
-
实现方式:父类类型作为方法形参,父类类型作为方法返回值
-
要求:继承,重写,向上转型
-
向上转型:父类类型的引用指向子类对象
优点:自动调用该子类重写父类中的方法;
缺点:不能调用到子类特有的方法
-
向下转型:真实子类的引用指向真实的子类对象
优点:可以调用到子类特有方法,或者子类重写父类的方法 缺点:转换异常:ClassCastException
5.instanceof:判断父类类型的引用指向子类对象的类型
-
15.补充知识
==、equals():
(1).基本数据类型:==比较值大小。
(2).引用数据类型:
a.String:==(比较内存地址); equals()比较字符串内容。
(原因是:源码中重写了Object类中equals()和toString())
b.其它引用类型:==和equals()比较的都是内存地址
第九章总结
1.抽象类与抽象方法:
(a)抽象类不能被实例化,但可以创建一个引用变量,其类型是一个抽象类指向非抽象的子类实例
(b)无方法体(即无大括号{})
2.抽象类与抽象方法的使用:
(a)抽象类中可以没有抽象方法,但包含类抽象方法的类必须被定义为抽象类
(b)如果子类没有实现父类的所有抽象方法,子类必须被定义为抽象类
(c)没有抽象构造方法,也没有抽象静态方法
(d)抽象类中可以有非抽象的构造方法,创建子类的实例时可以调用
3.接口:
public interface 接口名{
//接口成员
}
4:接口特性:
(1)接口不可以被实例化(常用作类型使用)
(2)实现类必须实现接口的所有方法
(3)实现类可以实现多个接口(java中的多继承)
(a)implements多个接口使用逗号隔开
(4)接口中的变量都是静态常量(public static final)
(5)所有的方法默认都是 public abstract
package com.kgc.usb;
//Usb接口
public interface Usb {
//服务 功能
public void service();
//概念性接口,系统能对外提供的所有服务
//实实在在的接口,interface修饰
}
package com.kgc.usb;
public class UsbDisk implements Usb{
public void service() {
System.out.println("插上U盘");
}
}
package com.kgc.usb;
//Usb风扇
public class UsbFan implements Usb{
public void service() {
System.out.println("插上风扇");
}
}
package com.kgc.usb;
public class Test {
public static void main(String[] args) {
Usb fan=new UsbFan();
fan.service();
Usb disk=new UsbDisk();
disk.service();
}
}
5.接口的使用
(1)接口中的成员变量默认都是public static final的,必须显示初始化
(2)接口中的方法除了成员变量和方法,不能包含其他
(3)一个接口不能实现另一个接口,但可以继承多个其他接口
6.抽象类与接口的使用原则
- 接口做系统与外界的交互窗口,提供服务
- 接口本身一旦制定,就不允许随意更改
- 抽象类可完成部分功能实现,还有部分功能可作为系统的扩展点
7.异常
捕获异常:try catch finally
try:执行可能产生异常的代码
catch:捕获异常
finally:无论是否发生异常,代码都要执行,不执行的唯一情况是在异常处理代码中执行了System.exit(非0数字);
8.try-catch 三种情况
(1)无异常,catch后的代码块将被忽略不执行
(2)有异常,且异常与catch()所捕获的异常相同,则进入catch()进行异常处理并打出异常,继续执行下面代码
package exceptiondemo;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入被除数:");
try {
int num1 = in.nextInt();
System.out.println("请输入除数:");
int num2 = in.nextInt();
System.out.println(num1 + "/" + num2 + "=" + num1 / num2);
} catch (ArithmeticException e) {//异常对象e
System.err.println("出现错误操作!");
//printStackTrace():打印异常堆栈信息
e.printStackTrace();
//返回异常描述字符串,并非所有错都有字符串返回
// System.out.println(e.getMessage());
}
System.out.println("感谢使用本程序!");
}
}
(3)有异常,但异常与catch()所捕获的异常不匹配,则中断运行,不再执行后面的代码块
9.try-catch -finally的两种情况
(1)如果try语句块中所有语句正常执行完毕,finally语句块也会被执行
(2)如果try语句块在执行过程中发生异常,无论这种异常是否被catch语句块捕获到,都将执行finally语句块中的代 码
注:try-catch -finally结构中try语句块是必须存在的,catch / finally语句块为可选,但两者至少出现其中之一
10.try-catch -finally中存在return
注:try-catch -finally中存在return时,finally语句块也会执行,发生异常时的执行顺序为,先执行catch语句块中return之前的语句,再执行finally语句块中的语句,最后执行catch语句块中return语句退出
package exceptiondemo;
import java.util.InputMismatchException;
//多重catch
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入被除数:");
try {
int num1 = in.nextInt();
System.out.println("请输入除数:");
int num2 = in.nextInt();
System.out.println(num1 + "/" + num2 + "=" + num1 / num2);
} catch (ArithmeticException e) {// 异常对象e
System.err.println("除数不能为0!");
// printStackTrace():打印异常堆栈信息
e.printStackTrace();
// 返回异常描述字符串,并非所有错都有字符串返回
// System.out.println(e.getMessage());
} catch (InputMismatchException e) {
System.out.println("输入必须是整数!");
e.printStackTrace();
} catch (Exception e) {
System.out.println("出现了其他错误操作!");
e.printStackTrace();
} finally {
System.out.println("感谢使用本程序!");
}
}
}
11.多重catch处理异常
(1)一段代码引发多种类型异常
(2)catch()异常的排列顺序必须是从子类到父类,最后一个一般是Exception类
(3)按照匹配原则,如果把父类放前面,后面的catch语句块将不会被执行
12.throws声明抛出异常与throw抛出异常比较:
throw | throws |
---|---|
生成并抛出异常 | 声明方法内抛出了异常 |
位于方法体内部,可作为单独语句使用 | 必须跟在方法参数列表后面,不能单独使用 |
抛出一个异常对象,且只能是一个 | 声明抛出异常类型,可以跟多个异常 |
13.自定义异常
当JDK中的异常类型不能满足程序的需要时,可以自定义异常类,步骤为:
1.定义异常类 2.编写构造方法,继承父类Exception的实现 3.实例化自定义异常对象 4.使用throw抛出
package exceptiondemo;
//自定义异常,调用在Person2中
public class AgeException extends Exception{
public AgeException() {}
public AgeException(String message) {
super(message);
}
}
package exceptiondemo;
public class Person2 {
private String name;
private int age;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) throws AgeException {
if (age < 100) {
this.age = age;
} else {
// 抛出异常
// AgeException为自定义异常,自定义异常类名为AgeException
throw new AgeException("年龄只能是1-100之间");
}
}
public String getSex() {
return sex;
}
public void setSex(String sex) throws Exception {
if (sex.equals("男") || sex.equals("女")) {
this.sex = sex;
} else {
// 抛出异常
throw new Exception("性别只能为男女!");
}
}
// 输出个人信息
public void print() {
System.out.println(this.getName() + "-" + this.getSex() + "-" + this.getAge());
}
public static void main(String[] args) {
Person2 p = new Person2();
try {
p.setAge(101);
p.print();
} catch (Exception e) {
e.printStackTrace();
}
}
}