这篇博客是对Java编程的全面总结，包括对Java历史的回顾，从环境配置到Eclipse的安装，再到基本的变量命名规则和数据类型。详细讲解了变量声明、赋值、常量以及Scanner的使用，还深入探讨了各种运算符和条件结构，如if、switch，以及循环结构如while、do-while、for。此外，还涵盖了数组、增强型for循环、程序调试和面向对象的基础知识，如类、对象、属性、方法、构造方法以及封装的概念。最后，提到了继承、访问权限控制、多态和异常处理等内容。
第一章 / 第二章总结
一：对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();
}
}
}
扫一扫
1747
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
