出现的异常
1 算术异常
ArithmeticException
2 想要的类型与输入的类型不匹配
InputMismatchException
3 空指针异常（访问了null对象）
NullpointerException
4 类型转换异常
ClasscastException
5 不能加载所需的类
ClassnNotFountException
6 数字格式转换异常 如把“abc”转换成数字
NumberFormatException
7 方法接收到非法参数
IllegalArgumentException
8 数组下标越界
ArrayIndexOutOfBoundException
列如
String a="高兴";
String b=null;
if(b.equals(a)){
System.out.println("学习");
}
@1 boolean的用法
Scanner input= new Scanner(System.in);
int nvsheng =20;
int nansheng ;
boolean jie ;
System.out.println("请输入男生人数");
nansheng=input.nextInt();
jie=nansheng>nvsheng;
System.out.println("男生比女生多吗"+jie);
@2
// 字符串的比较不能使用==
// 字符串的比较 "比较的字符串".equals(变量名);
@3
单= 是赋值 双等号==是等于的意思 列 if（week==7）
@4 三个乱输入的数字变成从小到大的顺序的用法
int temp=0；
if (a > b) {
// 交换 a 和 b 将小的赋值给a,大的赋值给b,但不能保证a是最小的
temp = a;
a = b;
b = temp;
}
if (a > c) {
// 交换 a 和 c 将小的赋值给a,大的赋值给c,保证a是最小的
temp = a;
a = c;
c = temp;
}
if (b > c) {
// 交换
temp = b;
b = c;
c = temp;
}
@5 标记法的使用
//声明变量 isRight 标记
// 运算的过程中是否出现错误 ，默认为 true ，没有错误
boolean isRight=true;
double result = 0;
Scanner input = new Scanner(System.in);
System.out.print("请输入第一个数：");
double num1 = input.nextDouble();
System.out.print("请输入第二个数：");
double num2 = input.nextDouble();
System.out.print("请输入运算符 + - * /:");
String choice = input.next();
switch (choice) {
case "+":
result = num1 + num2;
break;
case "-":
result = num1 - num2;
break;
case "*":
result = num1 * num2;
break;
case "/":
if (num2 == 0) {
System.out.println("除数不能为零");
isRight=false;
} else {
result = num1 / num2;
}
break;
default:
break;
}
if(isRight){
System.out.println("运算结果："+result);
}
@6 不是太理解的题
String shangm=""; 代表商品名字
double jia=0; 代表单价
double he=0; 代表一次计算的和
double zong=0; 代表n次循环之后的和
String answer="y"; 代表这个字符串是ture 用的是boolean方法
System.out.println("****************************************");
System.out.println("请选择购买的商品编号：");
System.out.println("1. T恤\t2.网球鞋\t3.网球拍");
System.out.println("****************************************");
while("y".equals(answer)){
System.out.println("请输入编号");
int bian=input.nextInt();
System.out.println("请输入数量");
double shu=input.nextDouble();
switch (bian) {
case 1:
shangm="t恤"; 代表选择中商品名字价格不一样可以用个统一变量代替
jia=10;
break;
case 2:
shangm="网球鞋"; 代表选择中商品名字价格不一样可以用个统一变量代替
jia=20;
break;
case 3:
shangm="网球拍"; 代表选择中商品名字价格不一样可以用个统一变量代替
jia=30;
break;
}
he=jia*shu; 代表一次购买用的总钱
zong=zong+he; 代表循环后n次购买的总钱
System.out.println("商品名字:\t"+shangm+"\t单价"+jia+"\t数量"+shu+"\t合计"+zong);
System.out.println("是否继续y/n");
answer=input.next();
}
System.out.println("折扣是0.8");
zong=zong*0.8;
System.out.println("应付金额"+zong);
System.out.println("实付金额");
double shifu=input.nextDouble();
System.out.println("找钱"+(shifu-zong));
第七题
System.out.println("输入一个整数输入0结束");
int num=input.nextInt();
int da=num;
int xiao=num;
while(num!=0){
if(num>da){
da=num;
}
if(num<xiao){
xiao=num;
}
System.out.println("输入一个整数输入0结束");
num=input.nextInt();
}
System.out.println("最大值"+da);
System.out.println("最小的"+xiao);
第八题 boolean isRight=ture
import java.util.Scanner;
public class Pro002 {
public static void main(String[] args) {
boolean isRight=true;
Scanner input=new Scanner(System.in);
System.out.println("欢迎使用MyShopping管理系统");
System.out.println("\n**********************************");
System.out.println("\t1.客户信息管理");
System.out.println("\t2.购物结算");
System.out.println("\t3.真情回馈");
System.out.println("\t4.注销");
System.out.println("**********************************");
System.out.print("请选择：");
do {
int ch = input.nextInt();
if(ch>=1 && ch<=4){
switch (ch) {
case 1:
System.out.println("客户信息管理");
isRight=true;
break;
case 2:
System.out.println("购物结算");
isRight=true;
break;
case 3:
System.out.println("真情回馈");
isRight=true;
break;
case 4:
System.out.println("注销");
isRight=true;
break;
}
}else{
System.out.println("输入错误，请重新输入数字：");
isRight=false;
}
} while (!isRight);
System.out.println("程序结束");
}
}
标记法的使用
import java.util.Scanner;
public class Pro002 {
public static void main(String[] args) {
int sum=0;
boolean isRight=true; //录入是否有误
Scanner input=new Scanner(System.in);
System.out.print("请输入学生姓名：");
String name=input.next();
for (int i = 1; i <=5; i++) {
System.out.print("请输入第"+i+"门课的成绩：");
int score=input.nextInt();
if(score<0){
isRight=false; //录入有误
System.out.println("抱歉，分数录入错误，请重新录入");
break;
}
sum+=score;
}
if(isRight){
System.out.println(name+"的平均分："+(sum/5.0));
}
}
}
多重for循环 易错点
for (int i = 1; i <= 3; i++) {
System.out.println("输入"+i+"个班级的分数");
int sum=0;
for (int j = 1; j <= 4; j++) {
System.out.println("输入"+j+"个同学的分数");
int scores=input.nextInt();
sum=sum+scores;
}
System.out.println("第"+i+"班级的平均分"+(sum/4));
}
外层循环控制行数 内层循环控制个数
外层循环控制行数 内层循环控制个数
外层循环控制行数 内层循环控制个数
外层循环控制行数 内层循环控制个数
外层循环控制行数 内层循环控制个数
外层循环控制行数 内层循环控制个数
外层循环控制行数 内层循环控制个数
外层循环控制行数 内层循环控制个数
System.out.print("请输入要打印的行数：");
int row = input.nextInt();
// 外层循环控制行数
for (int i = 1; i <= row; i++) {
for (int j = 1; j <= (2 * i - 1); j++) {
System.out.print("*");
}
System.out.println();
}
还是标记法的使用 还是标记法的使用 还是标记法的使用（意思就是说对某一个状态进行判断，当他输入一个数字 我就要跳出循环看是否猜对 猜对是一个状态 猜错也是一个状态）
boolean isRight=false;//没猜对 ture是猜对了， false是没猜对。
int[]nums=new int[]{8,4,2,1,23,344,12};
int sum=0;
System.out.println("数列的值是");
for(int i=0;i<nums.length;i++){
System.out.print(nums[i]+"\t");
sum=sum+nums[i];
}
//增强for
/*for(int num: nums){
System.out.print(num+"\t");
sum=sum+num;
}*/
System.out.println("数列的和是"+sum);
System.out.println("请猜猜有那个数");
int guess=input.nextInt();
for(int i=0;i<nums.length;i++){
if(nums[i]==guess){
isRight=true;
break;
}
}
if(isRight){
System.out.print("你猜对了");
}else{
System.out.print("你猜错了");
}
出错的题
import java.util.Scanner;
/**
* continue断点演示：计算成绩85分以上的学员人数
*
*/
public class Work002 {
public static void main(String[] args) {
int classnum = 3; // 班级数目
double sum = 0.0; // 成绩总和
double average = 0.0; // 平均成绩
int count = 0; // 记录85分以上学员人数
// 循环输入学员成绩
Scanner input = new Scanner(System.in);
for (int i = 0; i < classnum; i++) {
System.out.println("请输入第" + (i + 1) + "个班级的成绩");
for (int j = 0; j < 4; j++) {
System.out.print("第" + (j + 1) + "个学员的成绩：");
int score = input.nextInt();
if (score < 85) { // 成绩小于85，则跳出本轮循环
continue;
}
sum = sum + score; // 成绩85分以上才进行累加
count++;
}
}
average = sum / count; // 所有成绩85分以上的学员的平均分
System.out.println("所有成绩85分以上的学员的平均分为：" + average);
}
}
数组的总和应用
import java.util.Scanner;
public class Shuozu1116 {
public static void main(String[] args) {
// 定义一个字符串数组，保存Iphone手机的名称
String[] phones = { "Iphone5", "Iphone5s", null, "Iphone8", "IphoneX" };
Scanner input = new Scanner(System.in);
do {
System.out.println("***************************************");
System.out.println("\t欢迎使用手机名称信息管理系统");
System.out.println("\t1.查看所有手机名");
System.out.println("\t2.添加手机名");
System.out.println("\t3.修改手机名");
System.out.println("\t4.删除手机名");
System.out.println("\t5.退出");
System.out.println("***************************************");
System.out.print("请选择：");
int choice = input.nextInt();
switch (choice) {
case 1:
System.out.println("----->查看所有手机名");
// 遍历数组
for (String phone : phones) {
System.out.print(phone + " ");
}
System.out.println("\n");
continue;
case 2:
System.out.println("----->添加手机名");
int index = -1;
for (int i = 0; i < phones.length; i++) {
if (phones[i] == null) {
index = i;
break;
}
}
if (index == -1) {
// 数组已满
System.out.println("没有找到空的位置，数组已满，请联系管理员");
} else {
System.out.print("请输入新的手机名：");
phones[index] = input.next();
System.out.println("新增" + phones[index] + "成功");
}
System.out.println("\n");
continue;
case 3:
System.out.println("----->修改手机名");
System.out.print("请输入要修改的手机名：");
String uptPhone = input.next();
// 寻找下标
int uptIndex = -1;
for (int i = 0; i < phones.length; i++) {
if (phones[i] != null && phones[i].equals(uptPhone)) {
uptIndex = i;
break;
}
}
if (uptIndex == -1) {
System.out.println("您要修改的元素不存在");
} else {
// 提示用户输入新的手机名
System.out.print("请输入新的手机名");
phones[uptIndex] = input.next();
System.out.println("修改成功");
}
System.out.println("\n");
continue;
case 4:
System.out.println("----->删除手机名");
System.out.print("请输入要删除的手机名：");
String delPhone = input.next();
int delIndex = -1;
for (int i = 0; i < phones.length; i++) {
if (phones[i] != null && phones[i].equals(delPhone)) {
delIndex = i;
break;
}
}
if (delIndex == -1) {
System.out.println("您要删除的元素不存在");
} else {
// 删除操作，将后面的元素往前移
for (int i = delIndex; i < phones.length - 1; i++) {
phones[i] = phones[i + 1];
}
// 将数组的最后一个元素设置为null
phones[phones.length - 1] = null;
}
System.out.println("\n");
continue;
case 5:
break;
default:
System.out.println("你输入的数字有误请重新输入");
System.out.println("\n");
continue;
}
break;
} while (true);
}
}
冒泡排序法
n个数字来排队
俩俩相比小靠前
外层循环n-1(轮)
内层循环n-1-i（次）
对于n个数字排序 工比较几次得到结果 n*（n-1）/2 这是（升序）
int[] nums=new int[]{16,25,98,45,60};
int length=nums.length;
System.out.println("交换前");
for (int i : nums) {
System.out.println(i+"");
}
for (int i = 0; i < length-1; i++) {
for (int j = 0; j < length-1-i; j++) {
if(nums[j]>nums[j+1]){
int temp=nums[j];
nums[j]=nums[j+1];
nums[j+1]=temp;
}
}
}
System.out.println("\n交换后");
for (int i : nums) {
System.out.println(i+"");
}
如果是降序把大于号换成小于号
《Arrays.()的用法 使用前先导入 java.util.Arrays;》
1 俩个数组比较的用法
int[] num1={0,1,2,};
int[]num2={0,1,2};
boolean flag=Arrays.equals(num1,num2);
System.out.println(flag);
//比较的是数组的长度 和元素 俩个数组一样则true否则false
2 使用一个数值填充一个数值void
int[] num1={0,1,2,};
//填充前
for (int i = 0; i < num1.length; i++) {
System.out.println(num1[i]);
}
// 使用25这个数字，替换数组中每一个元素
Arrays.fill(num1, 25);
//填充后
for (int i = 0; i < num1.length; i++) {
System.out.println(num1[i]);
}
3如何使用copy of
int[] num1={0,1,2,};
int[]num2=Arrays.copyOf(num1, 3);
//将num1复制为一个长度为3的新数组num2；
for (int i = 0; i < num2.length; i++) {
System.out.println(num2[i]);
}
//把num2打印输出一个字符串
System.out.println(Arrays.toString(num2)); //to string的使用方法
//将num1复制为一个长度为6的新数组num3
int[]num3=Arrays.copyOf(num1, 6);
for (int i = 0; i < num3.length; i++) {
System.out.println(num3[i]);
}
4 to String复制字符串怎么使用
int[] num1={0,1,2,};
String zifu=Arrays.toString(num1);
System.out.println(zifu);
5 sort升序怎么使用
int[] num1={7,1,6,};
Arrays.sort(num1);
for (int i = 0; i < num1.length; i++) {
System.out.println(num1[i]);
}//这是升序
6 sort降序如何使用
int[]num1={5,6,8};
Arrays.sort(num1);
for(int i=num1.length-1; i>=0;i--){
System.out.print(num[i]);
注意 i的初始值是数组的长度-1 条件i是大于等于0 i是递减的
7 binarySearch查找元素在数组中的下标位置
必须满足是升序和int类型
int[] num1={7,1,6,};
Arrays.sort(num1);
int index=Arrays.binarySearch(num1, 7);
System.out.println(index);
图书馆管理系统
import java.util.Scanner;
public class Lianxitushu {
public static void main(String[] args) {
String[]books={"罗马假日", "白雪公主", "葫芦兄弟", null, null, null };
int[] states={ 1, 0, 0, 0, 0, 0};//1 已借出 0可借阅
int[] dates={1, 0, 0, 0, 0, 0};// 借出日期
int[] counts = { 15, 20, 30, 0, 0, 0 };// 借出次数
Scanner input = new Scanner(System.in);
do {
System.out.println("***************************************");
System.out.println("\t欢迎使用迷你图书管理器");
System.out.println("\t1.新增图书");
System.out.println("\t2.查看图书");
System.out.println("\t3.删除图书");
System.out.println("\t4.借出图书");
System.out.println("\t5.归还图书");
System.out.println("\t6.退出");
System.out.println("***************************************");
System.out.print("请选择：");
int choice = input.nextInt();
switch (choice) {
case 1:
System.out.println("----->新增图书");
System.out.println("请输入你要新增的图书");
String book=input.next();
int aindex=-1;
for (int i = 0; i < books.length; i++) {
if(books[i]==null){
aindex=i;
break;
}
}
if(aindex==-1){
System.out.println("货架已满 无法新增");
}else{
for (int i = 0; i < counts.length; i++) {
if(books[i]!=null&&books[i].equals(book)){
System.out.println("该书已存在不用新增");
break;
}else{
books[aindex]=book;
System.out.println("新增"+book+"成功");
//状态 日期 次数 对应的都是默认值 所以不用修改
break;
}
}
}
continue;
case 2:
System.out.println("----->查看图书");
System.out.println("序号\t状态\t名称\t日期\t借出次数");
for (int i = 0; i < books.length; i++) {
String state="可借阅";
String riqi="";
String count="";
if(books[i]!=null){
if(states[i]==1){
state="已借出";
}
if(dates[i]>0){
riqi=dates[i]+"日";
}
if(counts[i]>0){
count=counts[i]+"次";
}
System.out.println((i+1)+"\t"+state+"\t"+books[i]+"\t"+riqi+"\t"+count);
}else{
break;
}
}
continue;
case 3:
System.out.println("----->删除图书");
System.out.println("请输入要删除的图书");
String sbook=input.next();
int sindex=-1;
for (int i = 0; i <books.length; i++) {
if(books[i]!=null&&books[i].equals(sbook)){
sindex=i;
}
}
if(sindex==-1){
System.out.println("你要删除的图书不存在");
}else{
if(books[sindex].equals(sbook)&&states[sindex]==1){
System.out.println("该书已经借出去了不用删除");
}else{
for (int i = sindex; i < counts.length-1; i++) {
books[i]=books[i+1];
states[i]=states[i+1];
dates[i]=dates[i+1];
counts[i]=counts[i+1];
}
books[books.length-1]=null;
counts[counts.length-1]=0;
states[states.length-1]=0;
dates[dates.length-1]=0;
System.out.println("删除"+sbook+"成功");
}
}
continue;
case 4:
System.out.println("----->借出图书");
System.out.println("请输入你要借阅的图书");
String jbook=input.next();
for (int i = 0; i < books.length; i++) {
if(books[i]==null){
System.out.println("没有找到你要借阅的图书");
break;
}else if(books[i].equals(jbook)&&states[i]==1){
System.out.println("该书已经借出去了 你不能在借阅了");
break;
}else if(books[i].equals(jbook)&&states[i]==0){
System.out.println("请输入借阅的日期");
dates[i]=input.nextInt();
while(dates[i]<1&&dates[i]>31){
System.out.println("你输入的日期不对重新输入");
dates[i]=input.nextInt();
}
System.out.println("借阅"+jbook+"成功");
states[i]=1;//将书的状态修改为1 借出的状态
counts[i]=counts[i]+1;//次数加一
break;
}
}
continue;
case 5:
System.out.println("----->归还图书");
System.out.println("请输入你要归还的图书");
String gbook=input.next();
for (int i = 0; i < books.length; i++) {
if(books[i]==null){
System.out.println("这不是我们的书不用归还");
break;
}else if(books[i].equals(gbook)&&states[i]==0){
//找到了书但是书是可借阅状态 提示用户不用还
System.out.println("该书尚未借出 不用归还");
break;
}else if(books[i].equals(gbook)&&states[i]==1){
System.out.println("请输入归还日期");
int date=input.nextInt();
while(date<1||date>31||date<dates[i]){
System.out.println("你输入的归还日期有误 " +
"或者归还日期大于借出日期");
date=input.nextInt();
}
System.out.println("归还图书"+gbook+"成功");
int rent=(date-dates[i])*1;//计算租金 等于你借的日期-原来的日期
System.out.println("租金是"+rent+"元");
states[i]=0;
dates[i]=0;
break;
}
}
continue;
case 6:
System.out.println("退出系统");
break;
default:
System.out.println("选择的数字在1-5之间，请重新录入");
continue;
}
break;
} while (true);
System.out.println("谢谢 欢迎使用");
}
}
吃货联盟系统案列
吃货联盟系统案列
吃货联盟系统案
package cn.jbit.ordering;
import java.util.Scanner;
/**
* 吃货联盟订餐管理系统
*
*
*/
public class OrderingMsg {
public static void main(String[] args) {
// 数据主体：一组订单信息
String[] names = new String[4]; // 订餐人名称
String[] dishMegs = new String[4]; // 所选菜品
int[] times = new int[4]; // 送餐日期
String[] addresses = new String[4]; // 送餐地址
int[] states = new int[4]; // 订单状态： 0：已预定 1：已完成
double[] sumPrices = new double[4]; // 总金额
//初始化2个订单信息
names[0] = "张晴";
dishMegs[0] = "红烧带鱼 2份";
times[0] = 3;
addresses[0] = "天成路207号";
sumPrices[0] = 76.0;
states[0] = 1;
names[1] = "张晴";
dishMegs[1] = "鱼香肉丝 2份";
times[1] = 10;
addresses[1] = "天成路207号";
sumPrices[1] = 20.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; // 标志用户是否退出系统： true:退出系统
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(); // 记录用户选择的功能编号
boolean isAdd = false; //记录是否可以订餐
boolean isSignFind = false; //找到要签收的订单
boolean isDelFind = false; //找到要删除的订单
// 根据用户选择的功能编号执行相应功能
switch (choose) {
case 1:
// 我要订餐
System.out.println("***我要订餐***");
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"+"单价");
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 chooseDish = input.nextInt();
System.out.print("请选择您需要的份数:");
int number = input.nextInt();
String dishMeg = dishNames[chooseDish - 1]
+" "+ number + "份";
double sumPrice = prices[chooseDish - 1] * number;
//餐费满50元，免送餐费10元
double deliCharge = (sumPrice>=50)?0:6;
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"+date+"\t"+addresses[i]+"\t"+sumPrice+"\t"+state);
}
}
break;
case 3:
// 签收定单
System.out.println("***签收定单***");
System.out.print("请选择要签收的订单序号：");
int signOrderId = input.nextInt();
for(int i=0;i<names.length;i++){
//状态为已预定，序号为用户输入的订单序号：可签收
//状态为已完成，序叼为用户输入胡订单序号：不可签收
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("***删除订单***");
System.out.print("请输入要删除的订单序号:");
int delId = input.nextInt();
for(int i=0;i<names.length;i++){
//状态值为已完成 序号值为用户输入的序号：可删除
//状态值为已预定 序号值为用户输入的序号：不可删除
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];
}
//最后一位清空
names[names.length-1] = null;
dishMegs[names.length-1] = null;
times[names.length-1] = 0;
addresses[names.length-1] = null;
states[names.length-1] = 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:
// 退出系统
isExit = true;
break;
default:
//退出系统
isExit = true;
break;
}
if (!isExit) {
System.out.print("输入0返回：");
num = input.nextInt();
} else {
break;
}
} while (num == 0);
System.out.println("谢谢使用，欢迎下次光临！");
}
}
吃货联盟的框架
import java.util.Scanner;
public class Chilian {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
boolean flag=false;//false没有退出 true是退出
int num=-1;
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(); // 记录用户选择的功能编号
switch (choose) {
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
flag = true;
break;
default:
flag = true;
System.out.println("你输入的数字有误 请输入1-6之间选择");
break;
}
if(!flag){
System.out.println("输入0返回");
num=input.nextInt();
}else{
break;
}
} while (num==0);
System.out.println("谢谢光临 下次再见");
}
}
面向对象
第一题
public class School {
/**
* 类中的 成员变量（属性）
*
*/
public String name="课工厂";
public int classNum=20;
public int libNum=25;
/**
*
* 类中的 成员方法 输出 （方法） 中心信息
*
*/
public void print(){
System.out.println("线下服务中心"+name+"教室数目"
+classNum+"机房数"+libNum);
}
以上定义类 以下test
public static void main(String[] args) {
//创建对象（第1个）
School center1=new School();
//引用对象的属性 并赋值
center1.name="郑州翔天信鸽线下服务中心";
center1.classNum=19;
center1.libNum=20;
//创建对象（第2个）
School center2=new School();
//引用对象的属性 并赋值
center2.name="郑州翔天信鸽线下服务中心";
center2.classNum=19;
center2.libNum=20;
//引用对象的方法
center1.print();
center2.print();
}
}
第二题
public class YOURen {
public String name;
public int age;
public void pang(){
if(age>=18&&age<=60){
System.out.println(name+"的年龄是"+age+"门票是20");
}else{
System.out.println(name+"的年龄是"+age+"门票免费");
}
}
}
以上定义类 以下test
import java.util.Scanner;
public class TestYOURen {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
do {
YOURen ren1=new YOURen();
System.out.println("请输入姓名");
ren1.name = input.next();
if ("n".equals(ren1.name)) {
break;
}
System.out.println("请输入年龄");
ren1.age = input.nextInt();
ren1.pang();
} while (true);
System.out.println("退出程序");
}
}
第三题
public class Administrator {
//定义类的变量也就是 属性
public String name;
public String mima;
//定义类的方法
public void show(){
System.out.println("姓名"+name+"密码"+mima);
}
}
以上定义类 以下test
import java.util.Scanner;
public class TestAdministrator1 {
public static void main(String[] args) {
//创建对象
Administrator ren1=new Administrator();
//为对象的属性并赋值
ren1.name="admin1";
ren1.mima="111111";
Scanner input=new Scanner(System.in);
System.out.println("请输入用户名");
String name=input.next();
System.out.println("请输入密码");
String mima=input.next();
if(name.equals(ren1.name)&&mima.equals(ren1.mima)){
System.out.println("请输入新密码");
ren1.mima=input.next();
System.out.println("修改密码成功你的密码是"+ren1.mima);
}else{
System.out.println("用户名或者密码不匹配 请重新输入");
}
}
}
第四题 方法的使用 什么时候用void 什么时候用带有返回值的
public class ScoreCalc {
public int javascore;//java成绩
public int cscore;//c#成绩
public int dbscore;//DB成绩
public int suanZong(){
return javascore+cscore+dbscore; //用带有返还值得方法返还一个成绩值得到总成绩
}
public void kanzong(){
System.out.println("总成绩是"+suanZong());
} //不用返回结果 直接查看就行
public int suanavg(){
return suanZong()/3;
}
public void kanavg(){
System.out.println("平均分"+suanavg());
}
以上定义类 以下test
import java.util.Scanner;
public class TestScoreCalc {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
ScoreCalc ren=new ScoreCalc();
System.out.println("请输入java成绩");
ren.javascore=input.nextInt();
System.out.println("请输入cscore成绩");
ren.cscore=input.nextInt();
System.out.println("请输入dbscore成绩");
ren.dbscore=input.nextInt();
ren.kanzong();
ren.kanavg();//直接查看输出结果就行
}
}
总结 让用户输入的行为一般放在测试类中
参数的使用规则
数组 int [] names=new int[];
类型[] 变量=new 类型[];
创建对象
public 类型 对象=new 类型[]
private static Student[] students=new Student[4];
初始化赋值格式
students[0] = new Student("王小毛");
students[1] = new Student("周新宇");
students[2] = new Student("周伯通");
注意new Student();
当参数传递基本数据类型 参数变化不保留 基本数据类型参数传递的是数值。
当参数传递为引用的数据类型 参数变化会保留 引用数据类型 参数传地址.
stu.age=18；
test.work(stu)
system.out.pringt(stu.age)
类图中+号代表的是public -号代表的是private
建类图的工具有 1 powerdesigners（设计者） 2rose
constructor 代表构造的意思
构造方法和方法重载
构造方法和方法重载
构造方法和方法重载
public class Dog {
//声明属性时 未指定访问权限 默认是 包可见性
public String name ;
//=旺财
public int health ;
//=50
public int love ;
//=0
public String strain;
//=拉布拉多
public Dog(){
name="旺财";
health=50;
love=0;
strain="拉布拉多";
}
public Dog(String name,int health,int love,String strain){
this.name=name;
this.health=health;
this.love=love;
this.strain=strain; 类的带餐构造方法
}
public void print(){
System.out.println("名字是"+name+"健康值"+health+"亲密度"+love+"品种"+strain);
}
public static void main(String[] args) {
Dog dog=new Dog("小花",50,100,"雪纳瑞");
//已经相当调用了构造方法
dog=new Dog("小德子",100,200,"京巴");
dog.print();
//new Dog("小花",50,100,"雪纳瑞").print();
//new Dog("小花",50,100,"雪纳瑞").print();
//上面是俩中没有对象的输出
//构造方法1没有返回值 2与类名一样 3 参数数据类型或参数个数不同（和返回值 访问修饰符无关） //方法重载 1 在同一个类中 2 方法名相同 3参数的类型或者个数不同（返回值无关 访问修饰符无关）
//方法重载 在同一个类中 方法名字相同 参数的个数或者类型不同
//封装1 成员变量私有化 public改成private
// 2 设置set get访问器进行读写
//快捷键 alt+shift+s 会有getters 和setters这个 自动生成 set get访问器
//快捷键 alt+shift+s 会有constructor using fields 自动生成 构造方法的用法格式
这是类中的方法
public int getresult(int num1,int num2){
return num1+num2;
}
测试类
System.out.println(ji.getresult(2D, 3D));
加D的作用是类型的强制转换 int 转换成double 书上有介绍
static还可以用来修饰什么？
成员变量 静态变量，可以直接通过类名访问
static final String SEX_MALE="Q仔";
成员方法 静态方法，可以直接通过类名访问
static void print() { } 用类名调用： Penguin.print();
代码块
静态代码块，当Java虚拟机加载类时，就会执行该代码块
static变量类的成员变量包括
类变量（静态变量）
被static修饰的变量 在内存中只有一个拷贝
类内部，可在任何方法内直接访问静态变量
其他类中，可以直接通过类名访问
实例变量
没有被static修饰的变量
每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响
static变量的作用：（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间
包命名规范
package mypackage包名由小写字母组成，不能以圆点开头或结尾
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
package cn.kgc.javagroup.powerproject javagroup是部门名 powerproject是项目名
使用MyEclipse创建包的两种方法
1 分别创建包和类
2创建类的过程中创建类所在的包
一个类同时引用了两个来自不同包的同名类
必须通过完整类名来区分
每个包都是独立的，顶层包不会包含子包的类
package和import的顺序是固定的
package必须位于第一行（忽略注释行）
只允许有一个package语句其次是import
接着是类的声明
总和练习
模拟实现选民投票过程：一群选民进行投票，每个选民只允许投一次票，并且当投票总数达到20时，就停止投票
第一个类
package cn.kgc.oop.test;
public class Voter {//代表投标者
private static int totalPop=5;//静态变量 //private 成员变量的私有化 设置setget访问器
public static void setTotalPop(int totalPop){
Voter.totalPop=totalPop;//静态变量的使用 用类型。变量名//静态变量就要用到静态方法
}
public static int getTotalPop(){
return totalPop;
}
public static void vote(Student stu){
stu.setPop(stu.getPop()+1);//普通静态方法 投票给学生
}
}
第二个类
package cn.kgc.oop.test;
public class Student {//投票给的人
//三个实例变量
private String name;//被投票的人
private int pop;//获得的票数
public Student(){
//无参构造方法
}
public Student(String name){
this.name=name;
}//带参构造方法
public Student(String name,int pop){
this.name=name;
this.pop=pop;
}
public void setName(String name){//set 和get访问器进行name pop读写
this.name=name;
}
public String getName(){
return name;
}
public void setPop(int pop){
this.pop=pop;
}
public int getPop(){
return pop;
}
}
第3个类
package cn.kgc.oop.test;
/**
* 候选人的业务管理类
*/
public class StudentService {
private static Student[] students=new Student[4];//成员变量私有化set get读写
//声明过数组之后要初始化赋值 通过 for循环遍历输出每一个人
public static Student[] getStudents() {
return students;
}
public static void setStudents(Student[] students) {
StudentService.students = students;
}
static{
students[0]=new Student("彭刘妮");
students[1]=new Student("杨明威");
students[2]=new Student("杨雨桐");
students[3]=new Student("杨雨琪");
}//static 执行代码块.
//循环得到每个名字
public void print(){
for (int i = 0; i < students.length; i++) {
System.out.println((i+1)+"."+students[i].getName());
}
}
//循环得到票数
public void showPop(){
for (int i = 0; i < students.length; i++) {
System.out.println(students[i].getName()+",票数"+students[i].getPop());
}
}
}
第4个类
package cn.kgc.oop.test;
import java.util.Scanner;
public class VoterServie {
private StudentService service = new StudentService();
public void voteMenu() {
Scanner input = new Scanner(System.in);
// 获取总票数
int totalPop = Voter.getTotalPop();
for (int i = 0; i < totalPop; i++) {
System.out.print("请投票：");
int choice = input.nextInt();
// 通过循环控制保证choice为 1 2 3
Student stu = StudentService.getStudents()[choice - 1];
// 投票
Voter.vote(stu);
System.out.println("您投票给"+stu.getName()+",剩余票数："+(totalPop-i-1));
}
System.out.println("投票结束");
}
public void startMenu(){
System.out.println("****************************");
System.out.println("欢迎颜值王投票系统");
System.out.println("****************************");
service.print();
voteMenu();
service.showPop();
}
}
第5个类
package cn.kgc.oop.test;
public class TestVoter {
public static void main(String[] args) {
VoterServie service=new VoterServie();
service.startMenu();
} //要想在TestVoter这个类中执行VoterServie这个类中的方法
//那就要VoterServie这个类在TestVoter这个类中创建对象调用
//如果有 mian方法直接创建VoterServie的对象
//如果没有需要把VoterServie这个类当成一个变量形式创建对象
// 类似这样 private StudentService service = new StudentService();
}
public class Dog {
// 声明属性时，未指定访问权限，默认为包可见性
private String name; // 昵称
private int health; // 健康值
private int love;// 亲密度
private String strain; // 品种
// 选中最后一个属性， Alt+Shift+S 弹出的菜单中 选中
// Generate Setter和Getter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public class TestPenguin {
public static void main(String[] args) {
Penguin penguin=new Penguin();
//封装了Penguin类的sex属性为private,类的外部无法直接访问
//penguin.sex="妖";
penguin.setSex("妖");
penguin.setHealth(-1000);
System.out.println("健康值：");
penguin.print();
}
}
继承一些问题
package cn.kgc.oop.pet;
/**
* 宠物父类
* @author Administrator
*/
public class Pet {
private String name; // 昵称
private int health; // 健康值
private int love;// 亲密度
public String getName() { 封装
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
public Pet(){ 无参构造方法
System.out.println("我是宠物父类");
}
public Pet(String name, int health, int love) { 有参构造方法
this.name = name;
this.health = health;
this.love = love;
}
public void print() {
System.out.println("宠物的自白：我叫" + name + "，" + "健康值：" + health
+ ",和主人的亲密度：" + love);
}
}
子类
package cn.kgc.oop.pet;
public class Dog extends Pet {
private String strain;
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public Dog(){
}
public Dog(String name, int health, int love,String strain) {
super(name,health,love); 、、、、、、、、、、、、、、调用父类的构造方法
this.strain=strain; ，，，，，，，，，，，，，，调用自身子类 的成员变量
}
public Dog(String strain) {
this.strain = strain;
}
public void play(){
// 不能被继承的成员
// 1.private成员
//super.name;
}
}
super（）访问的是构造方法
super. 访问的是属性和方法
this（）访问自身的构造方法
常量的使用
1常量名一般大写
2声明常量一定要赋初始值
3一般和final一起使用
static final int PERSON_LIVE=1、、、、、人的生命只有一次
父类
package cn.kgc.oop.pet;
public class A {
public A(){
System.out.println("这是A类");
}
}
package cn.kgc.oop.pet;
子类
public class B extends A {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public B(){
System.out.println("这是B类");
}
public B(String name){
this();
System.out.println("我叫"+name);
}
public static void main(String[] args) {
//B b1=new B();
//B b2=new B("呵呵");
}
}
《对象数组》
package cn.kgc.oop;
public class StudentService {
public void xiugai(Student[] stus){
for (int i = 0; i < stus.length; i++) {
if(stus[i].score<60){
stus[i].score+=2;
}
}
}
public void show(Student[] stus){
for (int i = 0; i < stus.length; i++) {
stus[i].print();
}
}
public static void main(String[] args) {
StudentService s=new StudentService();
Student[] stus=new Student[2]; 出错的地方
Student stu1=new Student();
stu1.name="小1";
stu1.score=30;
Student stu2=new Student();
stu2.name="小二";
stu2.score=80;
stus[0]=stu1;
stus[1]=stu2;
s.xiugai(stus); 出错的地方
s.show(stus);
}
}
继承中的的5（是在子类中写的）
/////////先判断是不是一个类型 再把它转换一个类型 在拿要比的去比较
public boolean equals(Object other) {
if(other instanceof Student){
Student stu=(Student)other;//double a=2.0 int b=(double)a
if(this.id.equals(stu.id)){
return true;
}
}
return false;
}
、、、、、、、、、、、、、、、、、、
对象数组
package cn.kgc.oop.pet;
public class TestPet5 {
public static void main(String[] args) {
Pet[] pets = new Pet[2];
/*Dog d = new Dog("小花", 100, 200, "拉布拉多犬");
Penguin p = new Penguin("爱丽", 200, 50, "妖");
pets[0]=d;
pets[1]=p;*/
pets[0] = new Dog("小花", 100, 200, "拉布拉多犬");
pets[1] = new Penguin("爱丽", 200, 50, "妖");
for (int i = 0; i < pets.length; i++) {
if (pets[i] instanceof Dog) {
// 狗狗接飞盘
// 向下转型
Dog dog = (Dog) pets[i];
dog.catchingFlyDisc();
}
if (pets[i] instanceof Penguin) {
// 企鹅游泳
Penguin penguin = (Penguin) pets[i];
penguin.youYong();
}
}
}
}
《抽象方法和接口》
如果一个类同时继承了类和实现了接口要想得到接口的方法 就要把接口写前面
抽象类
不能被实例化 但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例 （也就是向上转型）
抽象类没有方法体 没{}
抽象类与抽象方法的使用
抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
没有抽象构造方法，也没有抽象静态方法 abstract和static不能出现在一个方法体
抽象类中可以有构造方法，子类可以去调用
接口不可以被实例化 常作为类型使用
接口里的方法一定要实现完 .......................
实现类可以实现多个接口 体现了接口的多继承
接口里的都是静态常量 和抽象方法 没有构造方法
面向对象设计原则
多用组合 少用继承
针对接口编程
相同点
都是抽象的都不能被实例化都有自己的抽象方法
不同点
抽象类可以有普通方法 子类可以去调用 重写
使用原则
接口做系统与外界交互的窗口
接口提供服务 接口本身一旦制定，就不允许随意修改抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点
父类作为返回值的使用
package cn.kgc.oop.calc;
/**
* 计算器抽象父类
*
* @author Administrator
*
*/
public abstract class Oper {
/*
* 抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
* 如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
* 没有抽象构造方法，也没有抽象静态方法
* 抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用
*/
/**
* 抽象方法
* @param num1
* @param num2
* @return
*/
public abstract double getResult(double num1, double num2);
public abstract void test();
}
package cn.kgc.oop.calc;
public class OperAdd extends Oper {
public double getResult(double num1, double num2) {
return num1+num2;
}
}
package cn.kgc.oop.calc;
/**
* 工厂类（生产对象）
*
* @author Administrator
*
*/
public class OperFactory {
public static Oper getInstance(String type) {
Oper oper =null;
if ("+".equals(type)) {
oper = new OperAdd();
} else if ("-".equals(type)) {
oper = new OperJian();
}
return oper;
}
}
package cn.kgc.oop.calc;
public class OperJian extends Oper {
public double getResult(double num1, double num2) {
return num1-num2;
}
}
注意是后面要加static 把计算机的父类作为返回值
package cn.kgc.oop.calc;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.print("请输入第一个数：");
double num1=input.nextDouble();
System.out.print("请输入第二个数：");
double num2=input.nextDouble();
System.out.print("请输入运算符 + - *");
String type=input.next();
//调用工厂类中的静态方法完成对象的创建
Oper oper=OperFactory.getInstance(type);
System.out.println("结果："+oper.getResult(num1, num2));
}
}
类和类之间的关系 类和接口之间的关系
继承 实现
这是垂直结构
平行结构：
依赖 关联 聚合 组合
再说一遍 等于null 是双等于 ==
包里面的java.lang类里的包不用导入可以直接拿来用
但是java.util.类的包需要导入才可以用
值得考虑的问题
Iusb usb=new Usbfeng();
new Usbfeng().work();
usb=new Usbshu();
new Usbshu().work();
《面向对象图书管理》
/**
* 新添图书 方法
*/
public boolean addbook(Book book){
boolean flag=false;
for (int i = 0; i < books.length; i++) {
if(books[i]==null){
books[i]=book;
flag=true;
break;
}
}
System.out.println("新增图书成功");
return flag;
}
/**
* 录入图书---------->太难理解了
*/
public String inputbook(){
Scanner input=new Scanner(System.in);
System.out.println("请输入图书名字");
return input.next();
}
/**
* 检查图书是否存在------->不理解BOOK 和returnde 结果
*/
private Book checkBook(){
String name;
do{
name=this.inputbook();
if(this.getIndexByName(name)==-1){
break;
}else{
System.out.println("图书名字已经存在");
continue;
}
}while(true);
return new Book(name);
}
《Scanner 只能输出纯数字》
package cn.xuanhuan.shuru.shuzi;
import java.util.Scanner;
public class NumberUtil {
public static int getNum(){
int num1=0;
Scanner input =new Scanner(System.in);
boolean flag=false;
do {
try {
System.out.println("请选择输入的数字");
num1 = input.nextInt();
flag=true;
} catch (Exception e) {
System.out.println("请重新输入一个数字");
input.nextLine();
}
} while (!flag);
return num1;
}
public static void main(String[] args) {
NumberUtil.getNum();
}
}
第二种方法
import java.util.Scanner;
public class Numberutil {
public static int getNumber(){
int num=0;
String num1="";
Scanner input =new Scanner(System.in);
do {
try {
System.out.println("请输入一个数字");
num1 = input.next();
num = Integer.parseInt(num1);
} catch (Exception e) {
System.out.println("请重新输入一整数");
continue;
}
break;
} while (true);
return num;
}
public static void main(String[] args) {
System.out.println(Numberutil.getNumber());
}
static
类的成员变量包括
类变量（静态变量）
被static修饰的变量 在内存中只有一个拷贝
类内部，可在任何方法内直接访问静态变量
其他类中，可以直接通过类名访问
实例变量就是 没有被static修饰的变量
静态块:用static{}裹起来的代码片段，
只会被执行一次(第一次加载此类时执行,比如说用Class.forName("")加载类时就会执行static block)，静态块优先于构造块执行。
静态块优先于构造块执行。
static修饰与非static修饰的区别
static、非private修饰 非static、private修饰
属性 类属性、类变量 实例属性、实例变量
方法 类方法 实例方法
调用方式 类名.属性 类名.方法() 对象.属性
对象.属性 对象.方法() 对象.方法()
归属 类 单个对象
在实例方法里不可以定义static变量
对于局部变量是基本数据类型的，在进行传参使用时，基本数据类型的局部变量值不变。
return 结束整个方法
引用基本类型
Person p1=new Person();
Person p2=new Person();
p1.age=18;
System.out.println(p1.age);
p2=p1;
p2.age=22;
System.out.println(p1.age);
System.out.println("------------------------------------");
基本数据类型
int num1=18;
int num2=num1;
System.out.println(num1);
num2=22;
System.out.println(num1);
-----------父类子类构造方法的调用
private String name;
public B(){
System.out.println("这是B类");
}
public B(String name,int age){
//super(age);
//this();
//super();
System.out.println("我是"+name+age);
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public static void main(String[] args) {
//B b=new B();
B b=new B("杨威",19);
super可以调用 父类的构造方法super() 父类的方法 super.方法 super。属性
接口中的属性访问修饰符只能是public 接口的修饰符只有：public
----------------》员工回家选择交通方式
private String name;
private String position;
public Yuan(){}
public Yuan(String name,String position){
this.name=name;
this.position=position;
System.out.println("我的名字叫"+name+"我的职位是"+position);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPosition() {
return position;
}
public void setPosition(String position) {
this.position = position;
}
/*public void gohome(Tools tool){
if(tool==null){
System.out.println("不回家");
}else{
tool.run();
}
}*/
public static Tools gohome(String xuanze){
Tools tool=null;
if("火车".equals(xuanze)){
return tool=new HuoTools();
}else{
return tool=new DidiTools();
}
}
public static void main(String[] args) {
/*Tools che1=new DidiTools();
Tools che2=new HuoTools();
Yuan ren1=new Yuan("虞姬", "射手");
ren1.gohome(che2);
Yuan ren2=new Yuan("妲己", "法师");
ren2.gohome(che1);*/
Yuan ren1=new Yuan("虞姬", "射手");
Scanner input=new Scanner(System.in);
System.out.println("选择你的工具");
String xuan=input.next();
Tools tool=Yuan.gohome(xuan);
tool.run();
//用数组存储一组基本类型 图示的名字 状态 日期 次数 现在用对象数组存储一组对象 每个对象存储自己的一组属性
---------java中=和+=的区别
short s1=1;
s1=s1+1 会报错 应该是 s1=(short)s1+1;
short s2=1;
s2+=1; 不会报错 编译器会自动将右边的强制转换为左面的
-----子类只要继承父类就可以直接在子类中通过this调用父类非私有的方法
----switch的case项不可以重复 switch里面放的是 int byte char short 注意case后面有没有break结束 否则往下执行
---局部变量 定义在方法内部 没有初始值（成员变量有初始值）必须定义切赋值才可以使用 在不同方法中可以有相同局部变量 一个方法不可以有
--this 只能调用实例变量 实例方法 构造方法 不能调用类变量和来方法 也不能调用局部变量