Youtube 视频:

java平台

开发步骤

注释

java内容介绍

java se课程介绍

第01讲 内容介绍 项目演示 原理剖析

java ee基础1

java ee中级部分

java ee高级部分

java 之父 gosling

java开发工具

java语言的特点

java第一个程序hello.java

配置JDK

//注释 (解释) 作者:
//功能:在控制台显示"hello"
//日期:2013年11月28日
//public:表示这个类是公共的,一个java文件中只能有一个public类
//class:表示这是一个类
//hello:类名(公共类的类名必须和文件名一致)
public class hello{
 //一个主函数,相当于是程序的入口
 public static void main(String args[]){
 //执行语句
 //System:是一个包
 //out.println是输入函数
 System.out.println("hello!");
 }
}

java程序运行关系

第02讲 变量 数据类型

对hello.java程序进行改过使之变为一个简单的加法运算程序

//注释 (解释) 作者:
//功能:在控制台显示"hello"
//日期:2013年11月28日
//public:表示这个类是公共的,一个java文件中只能有一个public类
//class:表示这是一个类
//jiafa:类名(公共类的类名必须和文件名一致)
public class jiafa{
 //一个主函数,相当于是程序的入口
 public static void main(String args[]){
 //执行语句
 //System:是一个包
 //out.println是输入函数
 // System.out.println("hello!");
 int a=10;//定义一个变量,变量名a,它的值10
 int b=20;//定义一个变量,变量名b,它的值20
 int result=a+b;//定义一个叫result变量将变量ab相加的值赋值给result
 //输出结果
 System.out.println("结果是"+result);
 }
}

为什么有变量

public class Test{
 public static void main(String []args){
 int a=1;//定义一个整形变量,取名a,并赋初值1
 int b=3;//定义一个整形变量,取名b,并赋初值3
 b=89;//给变量b赋89
 System.out.println(a);//输出语句,把变量a的值输出
 System.out.println(b);//把变量b的值输出
 }
}

java基本语法---基本数据类型

整数类型

小数(浮点)类型

布尔类型

字符类型

 int test1='a'+'b'; 输出值195
 char test2='a'+'b'; 输出值?
 char test3='中'; 输出值195

java基本语法--定义变量,初始化,赋值

定义变量

初始化变量

给变量赋值

java基本语法--基本数据类型转换

自动转换

强制转换

int a=(int)1.2;

int a=1; int a=1;
double b=4.5; double b=4.5;
a=b; b=a;
报错 成功
## 计算过程中的转换
int a=3;
int b=a+3.4;

java 基本语法--运算符

视频: 第03讲 运算符 流程控制

算术运算符:++自加. --自减。

int a=90;
a++; 等同于(a=a+1)
这时a等于? 91
int b=89;
b--; 等同于(b=b-1)
这时b等于? 88
int a=56;
int b=a++; 
System.out.println(b); 56
System.out.println(a); 57
***int b=++a;相当于a=a+1再将b=a;
 int b=a++;相当于b=a再将a=a+1。

算术运算符:+=左加. -=左减. /=左除. %=左取模

int a=90;
a+=90; (相当于a=a+90)
请问,a现在等于多少? 180
float b=89.7f;
b+=a; (相当于b=b+a)
请问,b现在等于多少? 269.7
int a=56;int b=90;
a-=34;b%=a; (相当于a=a-34,b=b%a)
System.out.println(b); 2
System.out.println(a); 22
----------------------------------------------------------------

运算符

关系运算符

	int a=90;int b=90;
	if(a==b){System.out.println("ok1");}
	b--;
	if(a>b){System.out.println("ok2");}
	if(a>=b){System.out.println("ok3");}

import java.io.*;//载入IO流包
public class Demo5{
 public static void main(String []args){
 try{
	//输入流,从键盘接收数
	InputStreamReader isr=new InputStreamReader(System.in);
	BufferedReader br=new BufferedReader(isr);
	//给出提示
	System.out.println("请输入第一个数");
	//从控制台读取一行数据
	String a1=br.readLine();
	System.out.println("请输入第二个数");
	String a2=br.readLine();
	//把String转为float
	float num1=Float.parseFloat(a1);
	float num2=Float.parseFloat(a2);
	if(num1>num2){System.out.println("第一个大");}
	if(num1==num2){System.out.println("相等");}
	if(num1<num2){System.out.println("第二个大");}	
	}catch(Exception e){ 
	 e.printStackTrace();
	}
	}
}

运算符--逻辑运算符

int a=90;int b=90;
if(a==b || a>8){System.out.println("ok1");}
b--;
if(a>b && a>45){System.out.println("ok2");}
if(!(a<=b)){System.out.println("ok3");}

java基本语法----三大流程控制

顺序控制

int a=7;
System.out.println("a="+a);
System.out.println("hello!");
a++;
System.out.println("a="+a);
System.out.println("0(∩_∩)0");
a++;
System.out.println("a="+a);

分支控制

	if(条件表达式){
		语句;
	}

	if(条件表达式){
		语句;
	}else{
		语句;
	}

	if(条件表达式){
		语句;
	}else if(条件表达式){
		语句;
	}else if(条件表达式){
		语句;
	}else{
		语句;
	}

	switch(条件表达式){ //***条件表达式数据类型,就和case常量表达式一致,否则就会报错。
	case 常量1:
		语句1;
			 //语句1至break中相当于{}可以加入相应程序代码
		break; //break,表示跳出switch语句
	case 常量2:
		语句1;
		break;
		...
	case 常量n:
		语句n;
		break;
	default:
		语句;
		break;
	}

循环控制

for (int a=0;a<10;a++){System.out.println("你好,我是刘德华同志!");}

int i=0;while(i<10){System.out.println("你好,我是刘德华同志!");i++;}

int i=0;do{System.out.println("你好,我是刘德华同志!");i++;}while(i<10)

// 把一个复杂的问是先拆解成简单问题
//三角形[Demo100.java]
public class Demo100{
	public static void main(String []args){
		//死去活来法-->打四次
		int lay=4;
		//表示有多少层
		for(int i=1;i<=lay;i++){
			//打印*
			for(int j=1;j<=i;j++){
				System.out.print("*");
			}
			System.out.println();//换行
		}
	}
}

//金字塔[Demo101.java]
public class Demo101{
	public static void main(String []args){
		int lay=10;//表示有多少层
		for(int i=1;i<=lay;i++){
			//找出规律
			//1->3 2->2 3->1 4->0找出空格
			for(int k=1;k<=lay-i;k++){
			System.out.print(" ");
			}
			//打印*
			//1->1 2->3 3->5 4->7找出星的规律
			for(int j=1;j<=(i-1)*2+1;j++){
				System.out.print("*");
			}
			System.out.println();//换行
		}
	}
}

//镂空金字塔[Demo102.java]
public class Demo102{
	public static void main(String []args){
		int lay=10;//表示有多少层
		for(int i=1;i<=lay;i++){
			//找出规律
			//1->3 2->2 3->1 4->0找出空格
			for(int k=1;k<=lay-i;k++){
			System.out.print(" ");
			}
			//打印*
			//1->1 2->3 3->5 4->7找出星的规律
			for(int j=1;j<=(i-1)*2+1;j++){
				//判断该层是否是顶层或者是底层
				if(i==1||i==lay){
				System.out.print("*");
				}else{
					//如果是第一个*
					if(j==1||j==(i-1)*2+1){
					System.out.print("*");
					}else{
						System.out.print(" ");
					}
				}
			}
			System.out.println();//换行
		}
	}
}

//空心菱形[Demo103.java]
public class Demo103{
	public static void main(String []args){
		int lay=4;//菱形上半部行数
		for(int i=1;i<=lay-1;i++){ //判断循环上半部分
			for(int k=1;k<=lay-i;k++){ //找行内*号前输出空格
				System.out.print(" ");
			}
			for(int j=1;j<=(i-1)*2+1;j++){ //找行内输出星的位置
				if(j==1||j==(i-1)*2+1){ //判断行最小长度和最大长度,并在最小长度和最大长度上输出*号,行内输入出空格。
					System.out.print("*");
				}else{
					System.out.print(" ");
				 }
			}
			System.out.println(); //换行
		}
		for(int i=1;i<=lay;i++){ //判断循环菱形下半部分
			for(int k=1;k<=i-1;k++){ //判断循环找*号前要输出空格处
				System.out.print(" ");
			}
			for(int j=1;j<=(lay-i)*2+1;j++){ //判断循环行长度
				if(j==1||j==(lay-i)*2+1){ //判断行最小长度和最大长度,并在最小长度和最大长度上输出*号,行内输入出空格。
					System.out.print("*");
				}else{
					System.out.print(" ");
				 }
			}
			System.out.println();//输出换行
		}
	}
}

//实心菱形[Demo104.java]
public class Demo104{
	public static void main(String []args){
		int lay=4;//菱形上半部行数
		for(int i=1;i<=lay-1;i++){ //判断循环上半部分
			for(int k=1;k<=lay-i;k++){ //找行内*号前输出空格
				System.out.print(" ");
			}
			for(int j=1;j<=(i-1)*2+1;j++){ //找行内输出星的位置
				System.out.print("*");
			}
			System.out.println(); //换行
		}
		for(int i=1;i<=lay;i++){ //判断循环菱形下半部分
			for(int k=1;k<=i-1;k++){ //判断循环找*号前要输出空格处
				System.out.print(" ");
			}
			for(int j=1;j<=(lay-i)*2+1;j++){ //判断循环行长度
				System.out.print("*");
			}
			System.out.println();//输出换行
		}
	}
}

1. java面向对象编程(1)-类与对象

//用前面学习过的知识写出代码
public class Demo107{
	public static void main(String []args){
		int a=49;//输入的名字49,50
		int cat1age=3; //第一只猫
		String cat1name="小白";
		String cat1color="白色";
		int cat2age=100; //第二只猫
		String cat2name="小花";
		String cat2color="花色";
		switch(a){
		case '1':
			System.out.println(cat1age+cat1color);
			break;
		case '2':
			System.out.println(cat2age+cat2color);
			break;
		default:
			System.out.println("张老太没有这只猫!");
		}
	}
}

java语言是面向对象的

类和对象的关系

//定义猫类
public class Demo105{
	public static void main(String []args){
		//创建一个猫对象
		Cat cat1=new Cat();//Cat是定义的一个数据类型
		//Cat cat1;
		//cat1=new Cat();// 等同于 Cat cat1=new Cat();
		//访问属性的 对象名.属性名字
		cat1.age=3;
		cat1.name="小白";
		cat1.color="白色";
		//创建第二只猫
		Cat cat2=new Cat();
		cat2.age=100;
		cat2.name="小花";
		cat2.color="花色"; 
	}
}
//java中如何定义一个类?[类名的首写字母大写]可根据程序的需要定义类
class Cat{
	//下面的就是类的成员变量/属性
	int agr;
	String name;
	String color;
	Master myMaster;
}
//引用类型,比如建个主人类
class Master{
	int age;
	String name;
	String address;
}

类--如何定义类

System.out.printlin(b.age);
Person a=new Person(); → 请问:b.age究竟是多少?
a.age=10;
a.name="小明";
Person b;
b=a;

Person1 a=new Person1();
a.age=10;
a.name="小明";
Person1 b;
b=a;
System.out.println(b.name);//输出"小明"
b.age=200;
System.out.println(a.age);//输出a.age为200

类--类的成员方法(成员函数)定义

//类的调用及方法调用[Demo108.java]
public class Demo108{
	public static void main(String []args){
	Person p1=new Person();
	p1.speak();//调用speak方法
	p1.jiSuan();//调用计算方法
	p1.jiSuan(200);//调用可以传入参数的计算方法
	p1.add(12,10);//调用两个数的和
	
	int res=p1.add2(23,34);//调用两个数的和并返回值到res中
	System.out.println("res返回值是:"+res);
	System.out.println("num1+num2+num3="+p1.add3(2,2.3f,4.5f));//返回类型一定要一致否则报错。
}
}
//定义名字的几个方法:
//1. 驼峰法 如myCry;2. 下划线法my_cry
//方法名在有不同参数的情况下可以使用同一个方法名,即有参数和没参数的方法可以同名
class Person{ //请注意类名首写字母应为大写如Person为类名 
	int age;
	String name;
	//1. 可以输出我是好人方法
	public void speak(){ //请注意方法名的首写字母应为小写如speak为方法名
		System.out.println("我是一个好人");
	}
	//2. 可以计算1+..+1000的方法
	public void jiSuan(){
		int result=0;
		for(int i=1;i<=1000;i++){
			result=result+i;
		}
	System.out.println("1+..+1000结果是"+result);
	}
	//3. 带参数的成员方法,可以输入n值并计算1+..+n
	public void jiSuan(int n){
		int result=0;
		for(int i=1;i<=n;i++){
			result+=i;
		}
		System.out.println("1+..+n结果是"+result);
	}
	//4. 计算两个数的和
	public void add(int num1,int num2){
		int result=0;	//与下面一句等同于return num1+num2;
		result=num1+num2;
		System.out.println("num1+num2="+result);
	}
	//5. 计算两个数的和,并将结果返回给主调(调用它的)函数
	//注意:返回类型和返回结果的类型要一致
	//注意:在调用某个成员方法的时候,给出的具体数值的个数
	//和类型要相匹配。
	public int add2(int num1,int num2){
		return num1+num2;
	}
	//6. 计算两个float数的和,并将结果返给主调函数
	public float add3(int num1,float num2,float num3){
		return num1+num2+num3;
	}
}

类--类的成员方法(函数)--如何理解

import java.io.*;
public class Demo110{
	public static void main(String []args){
		Cfb jiu=new Cfb();
			jiu.cf();
	}
}
class Cfb{
	public void cf(){
		try{
		//输入流,从键盘接收数
		InputStreamReader isr=new InputStreamReader(System.in);
		BufferedReader br=new BufferedReader(isr);
		//给出提示
		System.out.println("请输入1-9,按0退出:");
		//从控制台读取一行数据
		String a1=br.readLine();
		//把String转为int
		int num1=Integer.decode(a1);
			for(int i=1;i<=num1;i++){
				for(int j=1;j<=i;j++){
					System.out.print(i+"×ばつ"+j+"="+(i*j)+"\t");
				}
				System.out.println();			
			}
		}catch(Exception e){
		 e.printStackTrace();
		 }
	}
}

类定义的完善

//计算机类与对象的代码
import java.io.*;//加载IO流包
public class Demo109{
	public static void main(String []args){
		Computer Pc=new Computer();
			Pc.Brand="品牌";
			Pc.Color="颜色";
			Pc.Cpu="Cpu型号";
			Pc.Memory="内存容量";
			Pc.Hd="硬盘容量";
			Pc.Price="价格";
			Pc.Work="工作状态";
			try{
			//输入流,从键盘接收数
			InputStreamReader isr=new InputStreamReader(System.in);
			BufferedReader br=new BufferedReader(isr);
			//给出提示
			System.out.println("请输入0-9控制机器");
			//从控制台读取一行数据
			String a1=br.readLine();
			//把String转为float
			float num1=Float.parseFloat(a1);
			if(num1==0){Pc.open();}
			else if(num1==1){Pc.close();}
			else if(num1==2){Pc.sleep();}
			else if(num1==3){System.out.println(Pc.Brand);}
			else if(num1==4){System.out.println(Pc.Color);}
			else if(num1==5){System.out.println(Pc.Cpu);}
			else if(num1==6){System.out.println(Pc.Memory);}
			else if(num1==7){System.out.println(Pc.Hd);}
			else if(num1==8){System.out.println(Pc.Price);}
			else if(num1==9){System.out.println(Pc.Work);}
			else {System.out.println("输入错误!");}	
			}catch(Exception e){ 
	 		e.printStackTrace();
			}
	}
}
class Computer{
	String Brand;
	String Color;
	String Cpu;
	String Memory;
	String Hd;
	String Price;
	String Work;
	public void open(){
		System.out.println("开机");
	}
	public void close(){
		System.out.println("关机");
	}
	public void sleep(){
		System.out.println("休眠");
	}
}

2. java面向对象编程(1)-构造方法(函数)

//例人类构造方法[Demo111.java]
public class Demo111{
	public static void main(String []args){
		Person p1=new Person(12,"顺平");//给予不同的初始值,调用的构造方法不同,构造方法虽同名,但系统会根据初始值来选定构造方法。
	}
}
//定义一个人类
class Person{
	int age;
	String name;
	//默认构造方法
	public Person(){
	}
	//构造方法的主要用处是:初始化你的成员属性(变量)
	//构造方法
	public Person(int age,String name){
		System.out.println("我是构造1");
		age=age;
		name=name;
	}
	//构造方法2
	public Person(String name){
		System.out.println("我是构造2");
		name=name;
	}
}

/*
	this的必要性
*/
public class Demo112{
	public static void main(String []args){
		Dog dog1=new Dog(2,"大黄");
		Person p1=new Person(dog1,23,"郭德纲");
		Person p2=new Person(dog1,24,"刘谦");
		p1.showInfo();	
		p1.dog.showInfo();
	}
}
//定义一个人类
class Person{
	//成员变量
	int age;
	String name;
	Dog dog;//引用类型
	public Person(Dog dog,int age,String name){
		//可读性不好
		//age=age;
		//name=name;
		this.age=age; //this.age指this代词指定是成员变量age
		this.name=name; //this.name指this代词指定是成员变量name
		this.dog=dog;
	}
	//显示人名字
	public void showInfo(){
		System.out.println("人名是:"+this.name);
	}
}
class Dog{
	int age;
	String name;
	public Dog(int age,String name){
		this.age=age;
		this.name=name;
	}
	//显示狗名
	public void showInfo(){
		System.out.println("狗名叫"+this.name);
	}
}

public class Demo113{
	public static void main(String []args){
	/*	int total=0;
		Child ch1=new Child(3,"妞妞");
		ch1.joinGame();
		total++;
		Child ch2=new Child(4,"小小");
		ch2.joinGame();
		total++; 
	*/
		Child ch1=new Child(3,"妞妞");
		ch1.joinGame();
		Child ch2=new Child(4,"小小");
		ch2.joinGame();
		Child ch3=new Child(5,"大大");
		ch3.joinGame();
		System.out.println("共有="+Child.total);
	}
}
//定义小孩类
class Child{
	int age;
	String name;
	//static公共函数,total是静态变量,因此它可以被任何一个对象访问
	static int total=0; 
	public Child(int age,String name){
		this.age=age;
		this.name=name;
	}
	public void joinGame(){
		total++;
		System.out.println("有一个小孩加入了");
	}
}

java面向对象编程(2)--类变量. 类方法

//类变量的程序演示[Demo114.java]
public class Demo114{
	static int i=1;
	static{
		//该静态区域块只被执行一次
		i++;
		System.out.println("执行一次");
	}
	public Demo114(){ //建立Demo114()构造函数
		System.out.println("执行二次");
		i++;
	}
	public static void main(String []args){
		Demo114 t1=new Demo114(); //创建t1对象实例并调用Demo114函数
		System.out.println(t1.i);
		Demo114 t2=new Demo114();
		System.out.println(t2.i);
	}
}

//统计总学费的程序代码,加深static静态的方法由静态变量的访问[Demo115.java]
public class Demo115{
	public static void main(String []args){
		//创建一个学生
		Stu stu1=new Stu(29,"aa",340);
		Stu stu2=new Stu(29,"aa",240);
		System.out.println(Stu.getTotalFee());
	}
}
//学生类
class Stu{
	int age;
	String name;
	int fee;
	static int totalFee;
	public Stu(int age,String name,int fee){
		this.age=age;
		this.name=name;
		totalFee+=fee;
	}
	//返回总学费[这是一个类方法(静态方法)]
	//java中规则:类变量原则上用类方法去访问或操作
	public static int getTotalFee(){
		return totalFee;
	}
}

java面向对象编程的四大特征

抽象

封装--什么是封装

//封装案例[Demo116.java]
public class Demo116{
	public static void main(String []args){
		//创建一个职员
		Clerk clerk1=new Clerk("小花",24,4567.6f);
		System.out.println("名字是"+clerk1.name+"薪水"+clerk1.getSal());
	}
}
//职员
class Clerk{
	public String name;
	//private私有的,public公有的
	private int age;
	private float salary;
	public Clerk(String name,int age,float sal){
		this.name=name;
		this.age=age;
		this.salary=sal;
	}
	//通过一个成员方法去控制和访问私有的属性
	public float getSal(){
		return this.salary;
	}
}

定义类的改进 在提出包后,我们类的定义就更加完善了: class 类名{ class 类名{ class类名{ package包名; 待定.. 成员变量; → 成员变量; → 成员变量; → class 类名{ → } 成员方法; 构造方法; 成员变量; } 成员方法; 构造方法; } 成员方法; }

继承--为什么有?[Demo117.java]

//功能:说明继承的重要性
package com.abc;//包名
public class Demo117 {
	public static void main(String[] args) {
		Pupil p1=new Pupil();
		p1.printName();
	}
}
//将学生的共有属性提取,做一个父类
class Stu{
	//定义成员属性
	protected int age;
	public String name;
	public float fee;
	private String job;//私有将不被继承
	
	//编程中,如果你不希望子类继承某个属性或方法
	//则将其声明为private即可
	public void printName(){
		System.out.println("名字"+this.name);
	}
}
//小学生类
class Pupil extends Stu{
	//交学费
	public void pay(float fee){
		this.fee=fee;
	}
}
//幼儿
class Pre extends Pupil{
	//交学费
	public void pay(float fee){
		this.fee=fee*1.5f;
	}
}
//中学生类
class MiddleStu extends Stu{
	//交学费
	public void pay(float fee){
		this.fee=fee*0.8f;
	}
}
//大学生类
class ColStu extends Stu{
	//交学费
	public void pay(float fee){
		this.fee=fee*0.1f;
	}
}

//方法重载(overload)getMax
public class Demo119{
	public static void main(String []args){
		Abc2 abc1=new Abc2();
		System.out.println(abc1.getMax(12,14));
		System.out.println(abc1.getMax(24f,20f));
	}
}
class Abc2{
	//返回较大的整数
	public int getMax(int i,int j){
		if(i>j){
			return i;
		}else{
			return j;
		 }
	}
	public float getMax(float a,float b){
		if(a>b){
			return a;
		}else{
			return b;
		 }
	}
	//如果只是返回类型不一样,能否构成重载?不能够构成重载
/*	public double getMax(float d,double c){
		if(c>d){
			return c;
		}else{
			return d;
		 }
	}
	//如果只是控制访问修饰符不同,能否构成重载?不能够构成重载
	protected float getMax(float c,float d){
		if(c>d){
			return c;
		}else{
			return d;
		 }
	}*/
}

//子类方法覆盖父类方法[Demo120.java]
public class Demo120{
	public static void main(String []args){
		//创建一只猫
		Cat cat1=new Cat();
			cat1.cry();
		Dog dog1=new Dog();
			dog1.cry();
	}
}
//动物类
class Animal{
	int age;
	String name;
	//都会叫
	public void cry(){
		System.out.println("我是动物,不知道怎么叫");
	}
}
//猫猫类
class Cat extends Animal{
	//覆盖父类方法
	public void cry(){
		System.out.println("猫猫叫!");
	}
}
//狗狗类
class Dog extends Animal{
	//覆盖父类方法
	public void cry(){
		System.out.println("汪汪叫!");
	}
}

//Josephu问题(丢手帕问题)
//使用单向链表
public class Demo121 {
	public static void main(String[] args) {
		CycLink cyclink=new CycLink();
		cyclink.setLen(5);//链表长度
		cyclink.createLink();
		cyclink.setK(2);//从第几个人开始数
		cyclink.setM(2);//数几下
		cyclink.show();
		cyclink.play();
	}
}
class Child{
	int no;
	Child nextChild=null;
	public Child(int no){
		//给一个编号
		this.no=no;
	}
}
//单向环形链表
class CycLink{
	//先定义一个指向链表第一个小孩的引用
	//指向第一个小孩的引用,不能动
	Child firstChild=null;
	Child temp=null;
	int len=0;//表示共有多少个小孩
	int k=0;
	int m=0;
	//设置m数几下
	public void setM(int m){
		this.m=m;
	}
	//设置环形链表大小
	public void setLen(int len){
		this.len=len;
	}
	//设置从第几个人开始数数
	public void setK(int k){
		this.k=k;
	}
	//开始play
	public void play(){
		Child temp=this.firstChild;
		//1.先找到开始数数的人
		for(int i=1;i<k;i++){
			temp=temp.nextChild;
		}
		while(this.len!=1){
			//2.数m下
			for(int j=1;j<m;j++){
				temp=temp.nextChild;
			}
			//找到要出圈的前一个小孩
			Child temp2=temp;
			while(temp2.nextChild!=temp){
				temp2=temp2.nextChild;
			}
			//3.将数到m的小孩,退出圈
			temp2.nextChild=temp.nextChild;
			//让temp指向下一个数数的小孩
			temp=temp.nextChild;
			this.len--;
		}
		//最后一个小孩
		System.out.println("最后出圈的小孩:"+temp.no);
	}
	
	//初始化单向环形链表
	public void createLink(){
		for(int i=1;i<=len;i++){
			if(i==1){
				//创建第一个小孩
				Child ch=new Child(i);
				this.firstChild=ch;
				this.temp=ch;
			}else{
				//创建最后一个小孩
				if(i==len){
					Child ch=new Child(i);
					temp.nextChild=ch;
					temp=ch;
					temp.nextChild=this.firstChild;
				}else{
					//继续创建小孩
					Child ch=new Child(i);
					temp.nextChild=ch;
					temp=ch;	
				}
			}
		}
	}
	//打印该环形链表
	public void show(){
		//定义一个跑龙套
		Child temp=this.firstChild;
		do{
			System.out.print(temp.no+" ");
			temp=temp.nextChild;
		}while(temp!=this.firstChild);
	}
}

java面向对象编程(2)--四大特征

//演示继承. 方法覆盖. 多态
public class Demo122 {
	public static void main(String[] args) {
		//非多态演示
		Cat cat=new Cat();
		cat.cry();
		Dog dog=new Dog();
		dog.cry();
		//多态演示
		Animal an=new Cat();
		an.cry();
		an=new Dog();
		an.cry();
	}
}
//动物类
class Animal{
	String name;
	int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	//动物会叫
	public void cry(){
		System.out.println("不知道怎么叫");
	}
}
//创建Dog子类并继承Animal父类及覆盖cry方法
class Dog extends Animal{
	//狗叫
	public void cry(){
		System.out.println("汪汪叫");
	}
}
class Cat extends Animal{
	//猫自己叫
	public void cry(){
		System.out.println("猫猫叫");
	}
}

//演示子类继承父类. 方法覆盖. 多态方法
public class Demo123 {
	public static void main(String[] args) {
		//非多态演示
		System.out.println("非多态演示:");
		Cat cat=new Cat();
		cat.cry();
		Dog dog=new Dog();
		dog.cry();
		System.out.println();		
		//多态演示
		System.out.println("多态演示:");
		Animal an=new Cat();
		an.cry();
		an=new Dog();
		an.cry();
		System.out.println();	
		//多重多态演示
		System.out.println("多重多态演示:");
		Master master=new Master();
		master.feed(new Dog(),new Bone());
		master.feed(new Cat(),new Fish());
	}
}
//主人类
class Master{
	//给动物喂食物,使用多态,只要写一个方法
	public void feed(Animal an,Food f){
		an.eat();
		f.showName();
	}
}
//食物父类
class Food{
	String name;
	public void showName(){
		System.out.println("食物");
	}
}
//食物鱼子类
class Fish extends Food{
	public void showName(){
		System.out.println("鱼");
	}
}
//食物骨头子类
class Bone extends Food{
	public void showName(){
		System.out.println("骨头");
	}
}
//动物类Animal父类
class Animal{
	String name;
	int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	//动物会叫
	public void cry(){
		System.out.println("不知道怎么叫");
	}
	//动物吃东西
	public void eat(){
		System.out.println("不知道吃什么");
	}
}
//创建Dog子类并extends继承Animal父类及覆盖cry方法
class Dog extends Animal{
	//狗叫
	public void cry(){
		System.out.println("汪汪叫");
	}
	//狗吃东西
	public void eat(){
		System.out.println("狗爱吃骨头");
	}
}
class Cat extends Animal{
	//猫自己叫
	public void cry(){
		System.out.println("猫猫叫");
	}
	//猫吃东西
	public void eat(){
		System.out.println("猫爱吃鱼");
	}
}

//抽象类的必要性[Demo124.java]
public class Demo124 {
	public static void main(String[] args) {
		//Animal an=new Animal();抽象类不允许实例化
		Animal an=new Cat();
		an.cry();
		an=new Dog();
		an.cry();
	}
}
//抽象类abstract关键词
abstract class Animal{
	String name;
	int age;
	//动物会叫,使用了abstract抽象方法
	abstract public void cry();//抽象类中可以没有abstract抽象方法
	//抽象类内可以有实现方法
	public void sx(){
		System.out.println("实现方法");
	}
}
//当一个子类继承的父类是abstract抽象类的话,需要程序员把抽象类的抽象方法全部实现。
class Cat extends Animal{
	//实现父类的cry,其实类似上节学习中的子类覆盖父类
	public void cry(){
		System.out.println("猫猫叫");
	}
}
class Dog extends Animal{
	//实现父类的cry,其实类似上节学习中的子类覆盖父类
	public void cry(){
		System.out.println("汪汪叫");
	}
}

java面向对象编程(3)--接口

//接口的实现[Demo125.java]
//电脑,相机,u盘,手机
//usb接口
interface Usb{
	int a=1;//加不加static都是静态的,不能用private和protected修饰
	//声明了两个方法
	public void start();//接口开始工作
	public void stop();//接口停止工作
}
//编写了一个相机类,并实现了usb接口
//一个重要的原则:当一个类实现了一个接口,要求该类把这个接口的所有方法全部实现
class Camera implements Usb{
	public void start(){
		System.out.println("我是相机,开始工作了..");
	}
	public void stop(){
		System.out.println("我是相机,停止工作了..");
	}
}
//接口继承别的接口
class Base{
}
interface Tt{
}
interface Son extends Tt{
}
//编写了一个手机,并实现了usb接口
class Phone implements Usb{
	public void start(){
		System.out.println("我是手机,开始工作了..");
	}
	public void stop(){
		System.out.println("我是手机,停止工作了..");
	}
}
//计算机
class Computer{
	//开始使用usb接口
	public void useUsb(Usb usb){
		usb.start();
		usb.stop();
	}
}
public class Demo125 {
	public static void main(String[] args) {
		System.out.println(Usb.a);
		//创建 Computer
		Computer computer=new Computer();
		//创建Camera
		Camera camera1=new Camera();
		//创建Phone
		Phone phone1=new Phone();
		computer.useUsb(camera1);
		computer.useUsb(phone1);
	}
}

定义类的改进 有了接口,我们类的定义就更加完善了: class 类名{ class 类名{ class类名{ package包名; 成员变量; → 成员变量; → 成员变量; → class 类名{
} 成员方法; 构造方法; 成员变量; } 成员方法; 构造方法; } 成员方法; } ↓ ↓←←←←←←←←←←←←←←←←←←←←←←←←← package 包名; package 包名; class 类名 extends 父类{ class 类名 extends 父类 implements 接口名{ 成员变量; → 成员变量; 构造方法; 构造方法; 成员方法; 成员方法; } }

//实例:建立子类并继承了父类且连接多个接口[Demo126.java]
public class Demo126 {
	public static void main(String[] args) {
		System.out.println("继承了Monkey父类");
		Monkey mo=new Monkey();
		mo.jump();
		LittleMonkey li=new LittleMonkey();
		li.swimming();
		li.fly();
	}
}
//接口Fish
interface Fish{
	public void swimming();
}
//接口Bird
interface Bird{
	public void fly();
}
//建立Monkey类
class Monkey{
	int name;
	//猴子可以跳
	public void jump(){
		System.out.println("猴子会跳!");
	}
}
//建立LittleMonkey子类并继承了Monkey父类并连接了Fish和Bird接口
class LittleMonkey extends Monkey implements Fish,Bird{
	public void swimming() {
		System.out.println("连接了Fish接口!");
	}
	public void fly() {
		System.out.println("连接了Bird接口!");
	}
}

//用接口实现多态
public class Demo127 {
	public static void main(String []args){
		CarShop aShop=new CarShop();
		//卖出一辆宝马
		aShop.sellCar(new BMW());
		//卖出一辆奇瑞QQ
		aShop.sellCar(new CheryQQ());
		//卖出一辆桑塔纳
		aShop.sellCar(new Santana());
		System.out.println("总收入:"+aShop.getMoney());
	}
}
//汽车接口
interface Car{
	//汽车名称
	String getName();
	//获得汽车售价
	int getPrice();
}
//宝马
class BMW implements Car{
	public String getName(){
		return "BMW";
	}
	public int getPrice(){
			return 300000;
	}
}
//奇瑞QQ
class CheryQQ implements Car{
	public String getName(){
		return "CheryQQ";
	}
	public int getPrice(){
		return 20000;
	}
}
//桑塔纳汽车
class Santana implements Car{
	public String getName(){
		return "Santana";
	}
	public int getPrice(){
		return 80000;
	}
}
//汽车出售店
class CarShop{
	//售车收入
	private int money=0;		
	//卖出一部车
	public void sellCar(Car car){
		System.out.println("车型:"+car.getName()+"单价:"+car.getPrice
());
		//增加卖出车售价的收入
		money+=car.getPrice();
	}
	//售车总收入
	public int getMoney(){
		return money;
	}
}
运行结果:
车型:BMW 单价:300000
车型:CheryQQ 单价:20000
总收入:320000

//桑塔纳汽车
class Santana implements Car{
	public String getName(){
		return "Santana";
	}
	public int getPrice(){
		return 80000;
	}
}

java面向对象编程(3)--final

//final方法的使用[Demo128.java]
public class Demo128 {
	public static void main(String[] args) {
		Aaa aaa=new Aaa();
		aaa.show();
		Bbb bbb=new Bbb();
		bbb.show();
	}
}
class Aaa{ 
	int a=0;//如果a不赋初值,a是0。定义类型后应赋值
	//圆周率不让修改
	//带有final修饰的变量命名时应有_下划线来区分表示。这是java程序员的标准。
	final float reate_1=3.1415926f;//使用final可以保证,需要强制不被修改的数据一定要用final锁定
	//final int b; //使用final定义变量时一定要赋初值否则报错。
	//b=1;
	final public void sendMes(){//给成员方法用final来修饰则表示不可以被修改,不可被覆盖。
		System.out.println("发送消息");
	}
	public void show(){
		System.out.println("a="+a);
	}
}
final class Bbb extends Aaa{//定义类前加final表示该类不允许被继承
	public Bbb(){
		a++;
		//reate_1=reate+1;
	}
	/*public void sendMes(){
		System.out.println("发送消息")
	}*/
}

public class Work01{
	public static void main(String []args){
		int i=9;int j=4;
		int k=i+j;
		int l=i-j;
		int m=i*j;
		int n=i/j;
		int o=i%j;
		System.out.println("和:"+k+" 差:"+l+" 积:"+m+" 商:"+n+" 模:"+o);
	}
}

//正方形
public class Work02{
	public static void main(String []args){
		for(int i=1;i<5;i++){
			System.out.println("********");
		}
	}
}

//直角三角形
public class Work03{
	public static void main(String []args){
		for(int i=1;i<9;i++){
			for(int j=1;j<i;j++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

//三角形
public class Work04{
	public static void main(String []args){
		int lay=10;//行数
		for(int i=1;i<=lay;i++){//循环行
			for(int k=1;k<=lay-i;k++){//找空格
				System.out.print(" ");
			}
				for(int j=1;j<=(i-1)*2+1;j++){//找星位置并输入
					System.out.print("*");
				}
			System.out.println();//换行
		}
	}
}

//计算总费用和平均费用
import java.util.*;//加载包
public class Work05{
	public static int gbGame=320;//静态变量
	public static int gbGameT=5;
	public static int mp3=260;
	public static int mp3T=13;
	public static int people=18;
	public static void main(String []args){
		Scanner myScanner=new Scanner(System.in);//调用键盘输入
		showInfo(); //调用showInfo方法
		System.out.print("请输入手掌游戏机价格:");
		gbGame=myScanner.nextInt();
		System.out.print("请输入MP3价格:");
		mp3=myScanner.nextInt();
		System.out.print("请输入手掌游戏机数量:");
		gbGameT=myScanner.nextInt();
		System.out.print("请输入MP3数量:");
		mp3T=myScanner.nextInt();
		showInfo();
		}
	public static void showInfo(){ // 建立showInfo方法
		int total=gbGame*gbGameT+mp3*mp3T;//总价
		float average=(float)total/people;//平均价
		System.out.printf("总价: %d,平均价是: %f \n",total,average);
	}
}

//计算总费用和平均费用
import java.util.*;//加载包
public class Work06{
	public static int gbGame=0;//静态变量
	public static int gbGameT=0;
	public static int mp3=0;
	public static int mp3T=0;
	public static int people=0;
	public static void main(String []args){
		Scanner myScanner=new Scanner(System.in);//调用键盘输入
		System.out.print("请输入手掌游戏机价格:");
		gbGame=myScanner.nextInt();
		System.out.print("请输入MP3价格:");
		mp3=myScanner.nextInt();
		System.out.print("请输入手掌游戏机数量:");
		gbGameT=myScanner.nextInt();
		System.out.print("请输入MP3数量:");
		mp3T=myScanner.nextInt();
		System.out.print("请输入员工数:");
		people=myScanner.nextInt();
		showInfo();//调用showInfo方法
		}
	public static void showInfo(){ // 建立showInfo方法
		int total=gbGame*gbGameT+mp3*mp3T;//总价
		float average=(float)total/people;//平均价
		System.out.printf("总价: %d,平均价是: %f \n",total,average);
	}
}

//九九乘法表
import java.util.*;//加载包
public class Work07{
	public static void main(String []args){
		Scanner myScanner=new Scanner(System.in);//调用键盘输入
		System.out.print("请输入1-9中的一个数:");
		int num=myScanner.nextInt();
		for(int i=1;i<=num;i++){
			for(int j=1;j<=i;j++){
				System.out.print(i+"×ばつ"+j+"="+(i*j)+"\t");
			}
		System.out.println();
		}
	}
}

//输入两个数完成任务集合[Work08.java]
import java.util.*;//加载包
public class Work08{
	public static void main(String []args){
		Scanner myScanner=new Scanner(System.in);//调用键盘输入
		System.out.print("请输入一个数A:");
		int a=myScanner.nextInt();
		System.out.print("请输入一个数B:");
		int b=myScanner.nextInt();
		int e=0;//定义变量
		//求和	
		int c=a+b;
		System.out.println("和:"+c);
		//求平均数
		int d=(a+b)/2;
		System.out.println("平均数:"+d);
		//判断平均数是否大于第二个数
		if(d>b){ 
			e=1;
			System.out.println("平均数>第二个数"); 
		}else{
			e=0;
		 	System.out.println("小于"+b+"输出判断值"+e);
		}
		//第一个数减去上式的值
		int f=a-e;
		System.out.println("第一个数减去上式的值"+f);
		//第二个数乘上式的值
		int g=b*f;
		System.out.println("第二个数累乘上式的值"+g);
		//第一个数累加并赋给第一个数
		a+=g;
		System.out.println("第一个数累加第二个数赋给第一个数的值"+a);
	}
}

//打鱼--共有多少鱼[Work09.java]
public class Work09{
	public static void main(String []args){
		int total=0;
		int rest=4;//剩余的鱼
		total=((rest+1)*3+3)*2;//逆推
		System.out.println("鱼一共有:"+total);
	}
}

import java.util.*;//加载包
public class Work10{
	public static void main(String []args){
		Monkey mo=new Monkey();
		mo.scan();
	}
}
class Monkey{
	//day哪天的桃子数,sday吃了多少天剩下一个
	public static int peach(int day,int sday){//建一个peach方法
		if(day==sday){
			return 1;
		}else{
			return (peach(day+1,sday)+1)*2;//算法返回值
		}
	}
	public static void scan(){ //建立输入的方法
		int a=1;
		System.out.println("请输入要吃几天:");
		Scanner sr=new Scanner(System.in);
		int b=sr.nextInt();
		if(a<b){
			System.out.print(Monkey.peach(a,b));
		}else{
			System.out.println("不能小于等于1天");
			Monkey.scan();
		}
	}
}

import java.util.*;//加载包
public class Work11{
	public static void main(String []args){
		Scanner myScanner=new Scanner(System.in);//调用键盘输入
		System.out.print("请输入一个数N:");
		int n=myScanner.nextInt();
		int i=0;
		for(int m=0;m<n;m++){
			i=i+(m+1);
			System.out.println("m是"+m);
		}
		System.out.println("1+2+3+...+n的值是"+i);	
	}
}

//一个Cat类进行四则运算和面积计算[Work12.java]
//一个Cat类进行四则运算和面积计算
import java.util.*;//加载包
public class Work12{
	public static void main(String []args){
		Cat cat=new Cat();
		cat.scan1();
	}
}
class Cat{
	//输入方法
	public static void scan1(){
		System.out.println("题目类型如下");
		System.out.println("1. 四则运算");
		System.out.println("2. 面积运算");
		System.out.println("0. 退出程序");
		System.out.print("请选择要做题的类型,请入0-2:");
		Scanner sr=new Scanner(System.in);
		int x=sr.nextInt();
		switch(x){
			case 0:
				System.out.println("谢谢使用,再见!");//退出
				break;
			case 1:
				Cat.szys();
				break;
			case 2:
				Cat.mjys();
				break;
			default:
				System.out.println("输入有误,请重新输入!");
			Cat.scan1();//重复调用目录
		}
	}
	//四则运算方法
	public static void szys(){
			System.out.println("四则运算");
			System.out.println("1. 加法运算");
			System.out.println("2. 减法运算");
			System.out.println("3. 乘法程序");
			System.out.println("4. 除法程序");
			System.out.println("0. 返回上级");
			System.out.print("请选择要做题的类型,请入0-4:");
			Scanner sr=new Scanner(System.in);
			int y=sr.nextInt();
			switch(y){
				case 0:
					System.out.println("返回上级");
					Cat.scan1();//调用主目录
					break;
				case 1:
					System.out.println("进入加法运算,请输入第一个数:");
					Scanner jf1=new Scanner(System.in);
					int jf01=jf1.nextInt();
					System.out.println("进入加法运算,请输入第二个数:");
					Scanner jf2=new Scanner(System.in);
					int jf02=jf2.nextInt();
					float jfh=(float)jf01+(float)jf02;
					System.out.println(jf01+"+"+jf02+"="+jfh);
					System.out.println("已计算完成。");
					System.out.println("是否要继续使用?使用请输入1,返回请输入2,退出请输入任意数字:");
					Scanner cz01=new Scanner(System.in);
					int cz001=cz01.nextInt();
					if(cz001==1){
						Cat.szys();
					}else if(cz001==2){
						Cat.scan1();
					}else if(cz001!=1||cz001!=2){
						System.out.println("谢谢使用,再见!");
					}
					break;					
				case 2:
					System.out.println("进入减法运算,请输入第一个数:");
					Scanner jjf1=new Scanner(System.in);
					int jjf01=jjf1.nextInt();
					System.out.println("进入减法运算,请输入第二个数:");
					Scanner jjf2=new Scanner(System.in);
					int jjf02=jjf2.nextInt();
					float jjfh=(float)jjf01-(float)jjf02;
					System.out.println(jjf01+"-"+jjf02+"="+jjfh);
					System.out.println("已计算完成。");
					System.out.println("是否要继续使用?使用请输入1,返回请输入2,退出请输入任意数字:");
					Scanner cz02=new Scanner(System.in);
					int cz002=cz02.nextInt();
					if(cz002==1){
						Cat.szys();
					}else if(cz002==2){
						Cat.scan1();
					}else if(cz002!=1||cz002!=2){
						System.out.println("谢谢使用,再见!");
					}
					break;
				case 3:
					System.out.println("进入乘法运算,请输入第一个数:");
					Scanner cff1=new Scanner(System.in);
					int cff01=cff1.nextInt();
					System.out.println("进入乘法运算,请输入第二个数:");
					Scanner cff2=new Scanner(System.in);
					int cff02=cff2.nextInt();
					float cffh=(float)cff01*(float)cff02;
					System.out.println(cff01+"×ばつ"+cff02+"="+cffh);
					System.out.println("已计算完成。");
					System.out.println("是否要继续使用?使用请输入1,返回请输入2,退出请输入任意数字:");
					Scanner cz03=new Scanner(System.in);
					int cz003=cz03.nextInt();
					if(cz003==1){
						Cat.szys();
					}else if(cz003==2){
						Cat.scan1();
					}else if(cz003!=1||cz003!=2){
						System.out.println("谢谢使用,再见!");
					}
					break;
				case 4:
					System.out.println("进入除法运算,请输入第一个数:");
					Scanner cf1=new Scanner(System.in);
					int cf01=cf1.nextInt();
					System.out.println("进入除法运算,请输入第二个数:");
					Scanner cf2=new Scanner(System.in);
					int cf02=cf2.nextInt();
					float cfh=(float)cf01/(float)cf02;
					System.out.println(cf01+"÷"+cf02+"="+cfh);
					System.out.println("已计算完成。");
					System.out.println("是否要继续使用?使用请输入1,返回请输入2,退出请输入任意数字:");
					Scanner cf03=new Scanner(System.in);
					int cf003=cf03.nextInt();
					if(cf003==1){
						Cat.szys();
					}else if(cf003==2){
						Cat.scan1();
					}else if(cf003!=1||cf003!=2){
						System.out.println("谢谢使用,再见!");
					}
					break;
				default:
					System.out.println("输入有误,请重新输入!");
				Cat.szys();//循环调用子目录
			}
		}
	//面积运算方法
	public static void mjys(){
			System.out.println("面积运算");
			System.out.println("1. 三角形面积计算");
			System.out.println("2. 圆形面积计算");
			System.out.println("3. 方形面积计算");
			System.out.println("0. 返回上级");
			System.out.print("请选择要做题的类型,请入0-3:");
			Scanner sr=new Scanner(System.in);
			int z=sr.nextInt();
			switch(z){
				case 0:
					System.out.println("返回上级");
					Cat.scan1();//调用主目录
					break;
				case 1:
					System.out.println("进入三角形面积计算,请输入底:");
					Scanner sj1=new Scanner(System.in);
					int sjx01=sj1.nextInt();
					System.out.println("进入三角形面积计算,请输入高:");
					Scanner sj2=new Scanner(System.in);
					int sjx02=sj2.nextInt();
					float sjxh=((float)sjx01*(float)sjx02)/2;
					System.out.println("底"+sjx01+" 高:"+sjx02+" 面积="+sjxh);
					System.out.println("已计算完成。");
					System.out.println("是否要继续使用?使用请输入1,返回请输入2,退出请输入任意数字:");
					Scanner sj03=new Scanner(System.in);
					int sj003=sj03.nextInt();
					if(sj003==1){
						Cat.mjys();
					}else if(sj003==2){
						Cat.scan1();
					}else if(sj003!=1||sj003!=2){
						System.out.println("谢谢使用,再见!");
					}
					break;
				case 2:
					System.out.println("进入圆形面积计算,请输入半径:");
					Scanner y1=new Scanner(System.in);
					int bj=y1.nextInt();
					float ymjh=(float)bj*(float)bj*3.1415926f;
					System.out.println("半径:"+bj+" 面积:"+ymjh);
					System.out.println("已计算完成。");
					System.out.println("是否要继续使用?使用请输入1,返回请输入2,退出请输入任意数字:");
					Scanner y01=new Scanner(System.in);
					int y001=y01.nextInt();
					if(y001==1){
						Cat.mjys();
					}else if(y001==2){
						Cat.scan1();
					}else if(y001!=1||y001!=2){
						System.out.println("谢谢使用,再见!");
					}
					break;
				case 3:
					System.out.println("进入方形面积计算,请输入长:");
					Scanner c1=new Scanner(System.in);
					int c01=c1.nextInt();
					System.out.println("进入方形面积计算,请输入宽:");
					Scanner k2=new Scanner(System.in);
					int k02=k2.nextInt();
					float mjh=(float)c01*(float)k02;
					System.out.println("长:"+c01+" 宽:"+k02+" 面积:"+mjh);
					System.out.println("已计算完成。");
					System.out.println("是否要继续使用?使用请输入1,返回请输入2,退出请输入任意数字:");
					Scanner m03=new Scanner(System.in);
					int m003=m03.nextInt();
					if(m003==1){
						Cat.mjys();
					}else if(m003==2){
						Cat.scan1();
					}else if(m003!=1||m003!=2){
						System.out.println("谢谢使用,再见!");
					}
					break;
				default:
					System.out.println("输入有误,请重新输入!");
				Cat.mjys();//循环调用子目录
			}
		}
}

//超级马里奥人物建造及控制台数字操作
import java.util.*;
public class Work13 {
	public static void main(String[] args) {
		Scanner sr=new Scanner(System.in);//接收键盘输入
		System.out.println("输入1-25的数字,你可以移动马里奥,输入其它数字退出");
		int i=sr.nextInt();//将键盘输入数字赋值给i
		Maria m=new Maria();//建立调用Maria构造方法
		for(int a=i;a<=25;a--){
			if(i<25){
				m.move(i);
				i=sr.nextInt();
			}else{
				System.out.println("退出游戏!");
				break;
			}
		}
	}
}
class Maria{
	int x,y;
	//构造方法,初始化场景;确定地图,Maria的位置
	public Maria(){
		System.out.println("I'm Maria \n"+"@");
	}
	public void move(int i){
		for(int k=1;k<=25;k++){
			if(k==i){
				System.out.printf("@");
			}else{
				System.out.printf(".");
			}
		}
	}
}

int i=3;
int j=0;
double k=3.2;
if(j<k)
if(i==j)
System.out.println(i);
else
System.out.println(j);//执行此语句,得到结果0
else
System.out.println(k);

int i=4;
switch(i){
	default;
	System.out.println("default");//执行此语句
case 0:
	System.out.println("zero");//执行此语句
break;
case 1:
System.out.println("one");
case 2:
System.out.println("two");
}

a)
int i;
for(i=5,int j=10;i<10;j--){}//错
b)
int i,j;
for(i=0,j=10;i<10,j>0;i++,j--){}//错
c)
int i,k;
for(i=0,k=9;(i<10&&k>0);i++,j--){}//错
d)
int i,j
for(i=0;j=10;i<10;i++,j--){}//错

int i=1;
switch(i){
default:
System.out.println("default");
case 0:
System.out.println("zero");
break;
case 1;
System.out.println("one");//执行此语句
case2;
System.out.println("two");//执行此语句
}

a)
float x=1;//数据类型错误
switch(x){
case 1:
System.out.println("Got a 1");//错
}
b)
long y=1;//数据类型错误
switch(y){
case 1:
System.out.println("Got a 1");//错
}
c)
byte x=1;//低精转高精
switch(x){
case 1/1:
System.out.println("Got a 1");//正确
}
d)
int x=1;
int c=1;
switch(c){
case x;//需常量
System.out.println("Got a 1");//错
break;
e)
short x=1;//数据类型错误
switch(x){
case 3.2/3:
System.out.println("Got a 1");
break;
}
f)
shout x=1;//数据类型错误
switch(x){
case 1,2,3:
System.out.println("Got a 1");//错
break;
}

public class Myswitch{
	public static void main(String args[]){
		Myswitch ms=new Myswitch();
		ms.amethod();
	}
	public void amethod(){
		for(int a=0,b=0;a<2;b=++a,System.out.println("b="+b)){
			System.out.println("a="+a);
		}
	}
}
结果:a=0
 b=1
 a=1
 b=2

void looper(){
	int x=0;
	one:
	while(x<10){
		two:
		System.out.println(++x);
		if(x>3)
		break two;
	}
}//无法编译,break two;无法返回到two标签

public class Hope{
	public static void main(String args[]){
		Hope h=new Hope();
	}
	protected Hope(){
		int i=1;
		do{
		System.out.println(i);
		}while(++i<3);
	}
}
结果:1 2

//与电脑猜拳[Work14_1.java]
import java.util.*;
public class Work14_1 {
	public static void main(String[] args) {
			Kais.jingcyx();//调用开始游戏
	}
}
//开始退出游戏类
class Kais{
	public static void jingcyx(){
		System.out.println("是否开始猜拳游戏?按1开始,按0退出");
		Scanner sr=new Scanner(System.in);
		int x=sr.nextInt();
		switch (x){
			case 0:
				System.out.println("已退出游戏!");	
				break;
			case 1:
				System.out.println("游戏说明:0代表石头,1代表剪刀,2代表布");
				Caiquan.caiquan();
				break;
			default:
				System.out.println("输入错误,请重新输入!");
				Kais.jingcyx();
				break;
		}
	}
}
//猜拳游戏
class Caiquan{
	public static void caiquan(){
		int a1=0,b1=0,c1=0;
		System.out.print("请输入想玩的盘数:");
		Scanner p=new Scanner(System.in);
		int ps=p.nextInt();
		for(int i=1;i<=ps;i++){
			System.out.println("游戏已开始,请出拳!");
			Scanner m=new Scanner(System.in);
			int a=m.nextInt();//玩家出拳
			//Random n=new Random(2);//随机函数
			int b=(int)(0+Math.random()*(3-1+1));//随机产生0-2的int数,电脑出拳
			if(a==b){
				a1++;
				System.out.println("打平!");
			}else if((a-b)==-1||(a-b)==2){
				b1++;
				System.out.println("YOU Win!");
			}else{
				c1++;
				System.out.println("YOU LOSE");
			}
		}
		System.out.println("平:"+ a1 +"\n赢:" + b1 +"\n输:"+c1+"\n一共玩了"+(a1+b1+c1)+"局");
		Kais.jingcyx();
	}
}

//通过输入生日显示出生在周几。巫师看星座[Wrok15.java]
import java.util.*;
public class Work15{
	public static void main(String []args){ //程序入口
		Start ks=new Start();//调用程序开始类Start,并启用st方法
		ks.st();
	}
}
class Start{//程序开始类
	public void st(){
		System.out.println("年月日格式:19XX XX XX\n请输入出生年月日:");
		Scanner sr=new Scanner(System.in);
		int year=sr.nextInt();//输入年
		int month=sr.nextInt();//输入月
		int date=sr.nextInt();//输入日
		Rq r=new Rq();	//调用周几类
		r.rq(year,month,date);//将年月日数据传给周几类的rq方法中
		Xinz xz=new Xinz();//调用星座类
		xz.xinz(month,date);//将月日的数据传给星座类中的xinz方法中
		System.out.println("\n是否继续让巫师看星座?\n1. 继续\t2. 退出");
		Scanner sr1=new Scanner(System.in);
		int o=sr1.nextInt();
		if(o==1){
			Start qd=new Start();//输入1调用程序开始类
			qd.st();
		}else if(o!=1){	//不等于1退出
			Xinz tc=new Xinz();
			System.out.println("巫师为"+tc.getI()+"人看过星座");
			System.out.println("退出星座查询,Goodbay!");
		}
	}
}
class Rq{//周几类
	public void rq(int year,int month,int date){
		Calendar c = Calendar.getInstance(); //调用日期Calendar抽象类
		c.set(Calendar.YEAR,year);	
		c.set(Calendar.MONTH,month-1);
		c.set(Calendar.DATE,date);
		int week = c.get(Calendar.DAY_OF_WEEK);
		switch (week){ //判断输入的日期是周几
		case 1:
			System.out.println("星期日");
			break;
		case 2:
			System.out.println("星期一");
			break;
		case 3:
			System.out.println("星期二");
			break;
		case 4:
			System.out.println("星期三");
			break;
		case 5:
			System.out.println("星期四");
			break;
		case 6:
			System.out.println("星期五");
			break;
		case 7:
			System.out.println("星期六");
			break;
		}
	}
}
class Xinz{ //星座类
	public static int i=0;//定义静态变量i,i为统计调用人数计数器
	public void xinz(int month,int date){ //判断星座的方法
	i++;//调用此方法计数累器
		switch(month){
			case 1:{
				if(date>=20){
					System.out.println("水瓶座");
				}else{
					System.out.println("摩羯座");
				}
				break;
			}
			case 2:{
				if(date>=19){
					System.out.println("双鱼座");
				}else{
					System.out.println("水瓶座");
				}
				break;
			}
			case 3:{
				if(date>=21){
					System.out.println("白羊座");
				}else{
					System.out.println("双鱼座");
				}
				break;
			}
			case 4:{
				if(date>=20){
					System.out.println("金牛座");
				}else{
					System.out.println("白羊座");
				}
				break;
			}
			case 5:{
				if(date>=21){
					System.out.println("双子座");
				}else{
					System.out.println("金牛座");
				}
				break;
			}
			case 6:{
				if(date>=21){
					System.out.println("巨蟹座");
				}else{
					System.out.println("金牛座");
				}
				break;
			}
			case 7:{
				if(date>=23){
					System.out.println("狮子座");
				}else{
					System.out.println("巨蟹座");
				}
				break;
			}
			case 8:{
				if(date>=20){
					System.out.println("处女座");
				}else{
					System.out.println("巨蟹座");
				}
				break;
			}
			case 9:{
				if(date>=23){
					System.out.println("天平座");
				}else{
					System.out.println("处女座");
				}
				break;
			}
			case 10:{
				if(date>=23){
					System.out.println("天蝎座");
				}else{
					System.out.println("天平座");
				}
				break;
			}
			case 11:{
				if(date>=22){
					System.out.println("射手座");
				}else{
					System.out.println("天蝎座");
				}
				break;
			}
			case 12:{
				if(date>=22){
					System.out.println("摩羯座");
				}else{
					System.out.println("射手座");
				}
				break;
			}
		}
	}
	public int getI(){ //返回统计调用次数
		return i;
	}
}

import java.util.*;
public class Work16 {
	public static void main(String[] args) {
		//设定投票人数
		System.out.print("设定投票人数:");
		Scanner sr=new Scanner(System.in);
		int a=sr.nextInt();
		System.out.print("请输入第1位侯选人的名字:\n");
		Scanner sr1=new Scanner(System.in);
		String i1=sr1.nextLine();//键盘接收字符串
		System.out.print("请输入第2位侯选人的名字:\n");
		Scanner sr2=new Scanner(System.in);
		String i2=sr2.nextLine();
		System.out.print("请输入第3位侯选人的名字:\n");
		Scanner sr3=new Scanner(System.in);
		String i3=sr3.nextLine();
		System.out.println("本次选举将有"+ a +"人参与!");
		System.out.println("1号:"+i1+"\t2号:"+i2+"\t3号:"+i3);
		Xuanju tp=new Xuanju();
		tp.tp(a,i1,i2,i3);
	}
}
class Xuanju{
	public void tp(int a,String i1,String i2,String i3){
		int j1=0,j2=0,j3=0,qq=0;//计票器
		for (int i=1;i<=a;i++){ //统计投票
			System.out.println("请投票,投票请按1,2,3:");
			Scanner tp=new Scanner(System.in);
			int b=tp.nextInt();
			System.out.println("已有"+ i +"人投票");
			switch (b){
				case 1:
					j1++;
					break;
				case 2:
					j2++;
					break;
				case 3:
					j3++;
					break;
				default:
					qq++;
					break;
			}
		}
		
		if(j1>j2&&j1>j3){
			System.out.println(i1 +"得"+ j1 +"票\n"+ i2 +"得"+ j2 +"票\n"+ i3 +"得"+ j3 +"票\n"+"弃权票数"+qq);
			System.out.println("恭喜" + i1 + "当选班长!");
		}else if(j1<j2&&j2>j3){
			System.out.println(i1 +"得"+ j1 +"票\n"+ i2 +"得"+ j2 +"票\n"+ i3 +"得"+ j3 +"票\n"+"弃权票数"+qq);
			System.out.println("恭喜" + i2 + "当选班长!");
		}else if(j3>j1&&j2<j3){
			System.out.println(i1 +"得"+ j1 +"票\n"+ i2 +"得"+ j2 +"票\n"+ i3 +"得"+ j3 +"票\n"+"弃权票数"+qq);
			System.out.println("恭喜" + i3 + "当选班长!");
		}else {
			System.out.println(i1 +"得"+ j1 +"票\n"+ i2 +"得"+ j2 +"票\n"+ i3 +"得"+ j3 +"票\n"+"弃权票数"+qq);
			System.out.println("有同等票数,投票无效重新投票!");
		}
	}
}