第一本书《java面向对象总结》_front end plus-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44219317/article/details/89738238

这篇博客是对Java编程的全面总结，包括对Java历史的回顾，从环境配置到Eclipse的安装，再到基本的变量命名规则和数据类型。详细讲解了变量声明、赋值、常量以及Scanner的使用，还深入探讨了各种运算符和条件结构，如if、switch，以及循环结构如while、do-while、for。此外，还涵盖了数组、增强型for循环、程序调试和面向对象的基础知识，如类、对象、属性、方法、构造方法以及封装的概念。最后，提到了继承、访问权限控制、多态和异常处理等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第一章 / 第二章总结

一：对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

1539611470738

javac后

1539611738618

java后

1539611761226

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.多态：

核心作用：功能扩展，耦合性低
定义：条件不同，结果不同
实现方式：父类类型作为方法形参，父类类型作为方法返回值
要求：继承，重写，向上转型
1. 向上转型：父类类型的引用指向子类对象
  
  优点：自动调用该子类重写父类中的方法；
```
缺点：不能调用到子类特有的方法
```
2. 向下转型：真实子类的引用指向真实的子类对象
```
优点：可以调用到子类特有方法，或者子类重写父类的方法

缺点：转换异常：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();
		}
	}

}