1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//class 关键字,Demo01 类名
class Demo01
{   //左花括号：类定义代码的开始
  //public公共的；static:静态的；void:没有返回类型的;
  //main:主要的方法；相当于学校的大门;
  //参数是一个字符串类型的数组args,相当于要进入大门的一些人或物;
   public static void main(String[]args)
   {
	//系统.输出.打印(内容)
	System.out.println("demo01");
	System.out.println("ByTeachZhang");
   }	
  
}   //右花括号：类定义代码的结束;

1
2
3
4
5
6
7
8
9
//这时候老师加了个public
public class HelloSchool
{
   public static void main(String[]args){
	System.out.print("Henan");
	System.out.print("ZhengZhou");
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class TypeDemo 
{
	public static void main(String[] args) 
	{
		//1.字符型：关键字char,一般用来指性别等单个字符的变量
		char gender='男'; //java里面这个变量需要给它赋值后再使用;
		System.out.println(gender);
		//char和int互相转化；num是一个字符型,输出的时候一定是字符
		char num='a';  //num=97
		//a这个字符对应的计算机里面的编码就是97
		System.out.println(num);
		//2.boolean型
		//boolean flag=2>1; //2>1:true;如果判断相等，能不能用=号呢？
		//java：a=2;表示赋值把2赋值给a；a==2;表示判断a是否和2相等;
		boolean flag=2==1;
		System.out.println(flag);
		//3.浮点型;
		double height=1.80;
		System.out.println("身高是："+height);
		//*注意：系统默认的是double类型，75.2->float;double->float;
		//如何使用呢？在数据类型后面加f
		float weight=75.2f;
		System.out.println("体重是:"+weight);
		//4.整型；4个；如何记忆，从小到大；byte short int long
		//占用的空间：1个字节  2个字节 4个字节 8个字节
		//提问：为啥不是0-255呢？规定只是说了一点，更重要的是：
		//计算机里面考虑了符号的问题；-128-+127
		byte num1=-128;
		System.out.println(num1);
		int age=222;
		System.out.println(age);
		long num3=88888888;
		System.out.println(num3);
		//今天我们讲了基本数据类型的4类8个；都要使用以下;
		int a='a';
		System.out.println(a);
		//第36行代码a应该输出的是啥？？？97 为什么？？？
	}
}	

1
2
3
4
5
6
7
8
		int a=4,b=5; //a>b==>true
//		System.out.println(a>b?"结果1":"结果2");
		int result=a>b?a++:a--;
		System.out.println(result);
		//结果=a++; 先赋值,再运算(++)
		// 结果=++a
//		System.out.println(a>b?++a:--a);

1
2
3
4
5
6
7
8
9
10
11
12
//输入类;参数：System.in输入流;
		Scanner input=new Scanner(System.in);
		System.out.println("请输入您的姓名：");
		String name=input.next();
		System.out.println("请输入您的年龄:");
		int age=input.nextInt();
		System.out.println(name+":"+age);
		System.out.println("请输入身高:");//float
		float height=Float.parseFloat(input.next());  //字符串转Int ;Integer.parseInt(字符串)
		System.out.println("身高:"+height);
		//Integer,Float:这些是int,float的包装类型;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//老师的类名是不是首字母大写，一定要这样符合java的命令规范.
import java.util.Scanner;
class ScannerDemo 
{
	public static void main(String[] args) 
	{
		//Scanner类,输入类;C#:namespace
		//using MySql.SqlConnection;
		//java下面的概念不叫命名空间，叫包;
		//如果用到Scanner类，需要导入这个类所在的包
		//Scanner是引用数据类型，注意看new了，去内存new了分配空间
		Scanner input=new Scanner(System.in);
		System.out.println("请输入用户名:");
		String name=input.next();
		System.out.println("用户："+name);//+这时候的作用是连接作用
		System.out.println("请输入年龄：");
		int age=input.nextInt();
		System.out.println("年龄："+age);
		//小作业：Scanner实现 两个数字的加减乘除求余操作;
		//类型转换，大的数据类型转小的数据类型;
		//Integer.parseInt(字符串)->字符串转int类型;
		//格式：目标数据类型 变量=(目标数据类型)值;
		System.out.println("请输入一个小数:");
		int result=(int)input.nextDouble();
		System.out.println(result);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Scanner; //需要导入java.util包
class IfOne 
{
	public static void main(String[] args) 
	{
		//1.if的第一种使用方式;
		//boolean flag=5>4;
		//System.out.println(flag);
		//定义了一个Scanner的对象(变量)input
		//并且给它初始化（引用类型，需要new)
		Scanner input=new Scanner(System.in);
		System.out.println("请输入您是否进入到王者农药游戏...");
		String choice=input.next();//next()接受字符串
		System.out.println("测试输出"+choice);
		//针对字符串的等值判断，不能用==号，用equals进行比较
		//==号做等值判断，仅仅使用于基本数据类型
		//==号在引用数据类型判断，判断的是引用数据类型的
		//地址是否相同;
		if("Y".equals(choice)){
			System.out.println("您选择进入到游戏...");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Scanner;//导包
class IfTwo 
{
	public static void main(String[] args) 
	{
		//3.有多个条件的分支语句
		System.out.println("请输入您的存款，利于评估购车");
		Scanner input=new Scanner(System.in);
		//需要定义一个变量来接受用户的存款;
		double money=input.nextDouble();
		if(money>500){
			System.out.println("可以买个法拉驴");
		}else if(money>100){
			System.out.println("法拉第四...");
		}else if(money>50){
			System.out.println("可以买个宝骏...");
		}else if(money>10){
			System.out.println("可以买个长城H6");
		}else{
			System.out.println("可以买个超级环保的OFO");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class IQQuestion
{
	public static void main(String[] args) 
	{
		//只写思路;访问频率最高的一定在最前面
		if(money>=50 && money<=100){  //60%
			//中端客户的代码判断
		}else if(money<=10){
			//低端客户代码判断
		}else{
			//高端客户代码
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.Scanner;
class IfThree 
{
	public static void main(String[] args) 
	{
		//1.嵌套的if分支语句 
		System.out.println("请输入参赛选手的性别：");
		Scanner input=new Scanner(System.in);
		String gender=input.next();
		System.out.println("请输入选手的成绩：");
		double score=input.nextDouble();
		//根据性别进行判断;
		if("男".equals(gender)){
			System.out.println("进入男子组比赛");
			if(score<9.1){
				System.out.println("进入到决赛");
			}else{
				System.out.println("淘汰出局");
			}

		}else{
			System.out.println("进入女子组比赛");
			if(score<10.5){
				System.out.println("进入到决赛");
			}else{
				System.out.println("淘汰出局");
			}
		}
	}
}

1
2
3
4
5
6
7
8
9
10
			case "貂蝉":
				System.out.println("刺客，近战无敌..");
				break;
			case "昭君":
				System.out.println("刺客，近战无敌..");
				break;
			case "玉环":
				System.out.println("刺客，近战无敌..");
				break;

1
2
3
4
5
6
7
//当多个常量值，输出一样的时候，可以合并到一起;
			case "貂蝉":				
			case "昭君":				
			case "玉环":
				System.out.println("刺客，近战无敌..");
				break;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class WhileOne 
{
	public static void main(String[] args) 
	{
		//1.while循环;步骤
		//1.1 定义变量
		//1.2 while(条件判断)
		//1.2 循环体
		//1.3 变量的自增/自减 
		int num=1;
		while(num<=100){
			System.out.println("我要好好学习JAVA,练了"+num+"遍");
			num++; //计数器,像跑圈，统计圈数
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class DoWhileOne 
{
	public static void main(String[] args) 
	{
		//1.定义变量
		//2.do{} 循环体
		//3.while(条件判断)
		int num=1;
		do{
			System.out.println("练习宝典"+num+"遍");
			num++;
		}while(num<=100);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.Scanner;  //导包
class DoWhileTwo 
{
	public static void main(String[] args) 
	{
		//1.不固定次数的循环，需要用户自行输入值
		//1.定义变量,定义输出提示变量sc，并且让用户输入
		String result;				
		Scanner sc=new Scanner(System.in);
		//2.do while;字符串用的是equals(值)判断
		do{
			System.out.println("欧在使劲练习java...");
			System.out.println("老师满意吗？");
			result=sc.next();
		}while("N".equals(result));
		System.out.println("老师很满意恭喜通关!");
	}
}

1
2
3
4
5
6
7
8
9
//		while(true){
//			System.out.println("我爱Java");
//		}
		for(;;){
			//加条件；然后break;就退出了.
			System.out.println("我们要上火星了");
		}
		//这两个无限循环格式；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner;//导包
class AvgDemo 
{
	public static void main(String[] args) 
	{
		//求学生5门课的平均成绩,使用三种循环都可以;
		//1.定义变量;总成绩，输入对象变量sc
		double sum=0.0;
		Scanner sc=new Scanner(System.in);
		//2.利用for求5门课的总成绩;1 2 3 4 5
		for(int i=1;i<=5;i++){
			System.out.println("请输入第"+i+"课的成绩：");
			double score=sc.nextDouble();
			//sum=第一次的成绩+第二次的成绩+第3次+第4次+第五次;
			//score接受第1 2 3 4 5的成绩
			sum=sum+score;
		}
		System.out.println("平均成绩为："+sum/5);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package chapter03;

import java.util.Scanner;
public class LoginCheck {

	public static void main(String[] args) {
		//1.声明变量;
		int i;
		String name,pwd;
		Scanner input=new Scanner(System.in);
		//2.判断;最多输入3次;
		for(i=1;i<=3;i++){
			//用户输入;
			System.out.print("请输入用户名：");
			name=input.next();
			System.out.println("请输入密码:");
			pwd=input.next();
			//嵌套一个if，对或者错;
			if("admin".equals(name)&&"123aaa".equals(pwd)){
				System.out.println("用户名和密码正确！欢迎登陆！");
				break;//只要正确了，就退出循环;
			}else{
				System.out.println("用户名和密码错误！还有"+(3-i)+"次机会");
				continue;//结束本次循环，继续下一次循环;
			}
		}
		if(i==4){
			System.out.println("您输入次数超过3次，登陆失败!");
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.Scanner;

public class ArrayDemo {

	public static void main(String[] args) {
		String[]longmen=new String[5];//1.声明，定义长度为5的字符串类型的数组;
		Scanner input=new Scanner(System.in);
		//longmen={"","","","",""};大家试验;
		//数组名[下标]=值;注意：数组下标从0开始；最大值：长度-1；
//		longmen[0]="郝明超";
//		longmen[1]="方一帆";
//		longmen[2]="左恩光";
//		longmen[3]="小锐锐";
//		longmen[4]="赵美丽"; //数组最大值是4；
//		longmen[5]="张老师"; //写代码的时候没有错，运行的时候出错；数组越界异常；
		for(int i=0;i<5;i++){  //2.输入
			System.out.println("请输入第"+(i+1)+"位客户的名称：");
			longmen[i]=input.next();
		}
		//3.遍历;
//		for(int i=0;i<5;i++){
//			System.out.println(longmen[i]);
//		}
		//for in格式：数组类型 变量名 : 数组（或集合）
		for(String name:longmen){
			System.out.println(name);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class ArrayThree 
{
	public static void main(String[] args) 
	{
		//还是定义一个字符串类型的数组;
		//使用{}给数组赋值的时候，前面不需要new之类的格式
		//它是数组名={值1,...值n},直接赋值格式.
		//String[]names={"杰克.马","Pony.马","冬梅.马"};
		int[]names={11,12,18,19};
		//System.out.println(names.length);
		//格式：表示变量依次从数组里面取值
		//for(数组数据类型 变量 :数组名){}
		for(int name:names){
			System.out.println(name);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class TwoArray 
{
	public static void main(String[] args) 
	{
		//二维数组;3行5列;
		int[][]twoArray=new int[3][5];
		//二维数组的长度指的是它的行数;
		//System.out.println(twoArray.length);
		//如何给二维数组赋值;先搞定第一行;
		twoArray[0][0]=1;
		twoArray[0][1]=2;
		twoArray[0][2]=3;
		twoArray[0][3]=4;
		twoArray[0][4]=5;
		//如何给二维数组赋值;再搞定第二行;
		twoArray[1][0]=2;
		twoArray[1][1]=4;
		twoArray[1][2]=6;
		twoArray[1][3]=8;
		twoArray[1][4]=10;
		//如何给二维数组赋值;再搞定第三行;
		twoArray[2][0]=3;
		twoArray[2][1]=6;
		twoArray[2][2]=9;
		twoArray[2][3]=12;
		twoArray[2][4]=15;
		//循环输出;不同的是行数不同;
		for(int j=0;j<5;j++){
			System.out.println(twoArray[0][j]);
		}
		for(int j=0;j<5;j++){
			System.out.println(twoArray[1][j]);
		}
		for(int j=0;j<5;j++){
			System.out.println(twoArray[2][j]);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class TwoArray2 
{
	public static void main(String[] args) 
	{
		int[][]twoArray={
					{1,2,3,4,5},
					{11,22,33,44,55},
					{111,222,333,444,555}
				};
		//先简化下面的代码
		for(int i=0;i<3;i++){
			//把刚才重复的代码拷贝过来
			for(int j=0;j<5;j++){
				System.out.println(twoArray[i][j]);
			}
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
//1.定义变量；
		int age;
		Scanner input=new Scanner(System.in);
		//2.输入数据;
		System.out.println("请输入您的年龄:");
		age=input.nextInt();
		//3.业务判断；
		String[]arr={"儿童","少年","青少年","青年","中年","中老年"};
		//4.输出;
		System.out.println("年所处的年龄阶段:"+arr[age/10]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//1.声明变量数组a 30,数组b  6
		int[]a=new int[30];
		int[]b=new int[6];
		//2.赋值;
		for(int i=0;i<30;i++){
			a[i]=i*2;
		}
		//2.2输出当前a
		for(int n:a)
			System.out.print(n+"t");
		System.out.println();
		//3.每5个求一下平均值;4 9 14 19；扩充考虑有n个平均值如何做
		for(int i=4;i<30;i+=5){
//			b[0]=a[0]+a[1]+a[2]+a[3]+a[4];
			b[i/5]=(a[i-4]+a[i-3]+a[i-2]+a[i-1]+a[i])/5;
		}
		for(int n:b)
			System.out.print(n+"t");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//动态扩充若干数的平均值;
int[] array = new int[30];
		for (int i = 1; i < 31; i++) {
		    array[i-1] = i*2;
		}
		for (int i : array) {
		    System.out.print(i+",");
		}
		System.out.println();
		int[] b = new int[6];
		int steps = 5;
		int c = 0;
		for (int i = 0; i < array.length; i=i+steps) {
		    int sum = 0;
		    for (int j = i; j <i+steps; j++) {
		        sum=sum+array[j];
		    }
		    System.out.print(sum+",");
		
		    b[c++] = sum/steps;
		}
		System.out.println();
		for (int n:b)
		{
		    System.out.print(n+",");
		}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class StringOne 
{
	public static void main(String[] args) 
	{
		//1.定义变量，并赋值;
		String s1="hello";            //字符串直接赋值
		//只要碰到new，就表示去内存分配空间
		String s2=new String("hello");//引用数据类型直接new
		System.out.println(s1==s2);  //==  比较的是内存的地址；
		//要比较两个字符串s1 s2内容是否一致？
		System.out.println(s1.equals(s2)); //true
		String s3="hello";
		System.out.println("s3 s1内容："+s1.equals(s3));
		System.out.println("s3==s1:"+(s1==s3));
		//s1==s3,返回的地址是一致的，结果true
		//JVM：字符串太常用了，针对直接赋值的形式，先去内存区域
		//查找是否有相同的内容的字符串空间，如果有，则将该内存的
		//地址赋值给当前字符串变量。
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//不可变字符串类  
class StringAppend 
{
	public static void main(String[] args) 
	{
		//测试一下String类的追加;String类：不可变字符串类;
		String s1="hello";
		//String s2=s1+"tea.zhang";	//没有append
		//s1.concat(新字符串):将新串添加到s1末尾
		String s2=s1.concat(".tea.zhang");
		System.out.println(s2);  //hello.tea.zhang
		System.out.println(s1==s2);  
		//+号连接的时候返回值:false
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//可变字符串类
class StringBufferDemo
{
	public static void main(String[] args) 
	{
		//StringBuffer类：可变字符串类;引用数据类型
		//"hello"是一个字符串，不能直接给StringBuffer类型赋值
		//二者类型不一致;
		//StringBuffer sb=new StringBuffer("hello");
		StringBuffer sb=new StringBuffer();//():不放内容
		sb.append("hello");   //append:追加
		System.out.println(sb);		
		System.out.println(sb==sb.append("tea.zhang"));
		//sb:地址1100；
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//忽略大小写？？？
		String name="admin";
		String str;
		System.out.println("请输入用户名：");
		Scanner input=new Scanner(System.in);
		str=input.next();
		//只有你输入的内容是admin的时候，进入
		//equalsIgnoreCase():忽略大小写的方法;
		if("admin".equalsIgnoreCase(str)){
//			str.toUpperCase():转换为大写;str.toLowerCase()
			System.out.println("登录进入");
		}else{
			System.out.println("登录失败");
		}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class StringVSStringBuffer 
{
	public static void main(String[] args) 
	{
		//比较一下String类和StringBuffer类的效率;
		//利用当前系统毫秒数得到当前的时间
		long startTime=System.currentTimeMillis();
		//System.out.println(startTime);
		String s="hello";
		for(int i=0;i<100000;i++)
			s+=i;    //利用不可变类，创建新的字符串;
		//再次定义一个变量，得到当前系统的时间毫秒数;
		long endTime=System.currentTimeMillis();
		//System.out.println(endTime);
		System.out.println("不可变类耗时:"+(endTime-startTime)+"毫秒");
		//再次测试可变字符串类;
		//StringBuffer sb=new StringBuffer("hello");
		StringBuilder sb=new StringBuilder("hello");
		//测试：Builder类 0毫秒；Buffer类：2毫秒
		//再次得到系统的毫秒数，开始时间;
		startTime=System.currentTimeMillis();
		//中间就是利用循环来测试可变字符串类的效率
		for(int i=0;i<100000;i++){
			sb.append(i);
		}
		//System.out.println(sb);输出测试
		//再次得到结束时间
		endTime=System.currentTimeMillis();
		System.out.println("可变字符串类:"+(endTime-startTime)+"毫秒");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.Date;   //记着导包，java.util包;工具包;
//家政服务员，你带工具去服务;
import java.text.SimpleDateFormat;//导包
class  DateDemo
{
	public static void main(String[] args)throws Exception
	{
		//日期时间类;
		Date date=new Date();
		System.out.println(date);
		//输出的是欧洲这种时间格式;
		//转换成我们中文的时间日期格式;
		//利用一个转换类;参数格式：yyyy-mm-dd
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
		//将给定的 Date 格式化为日期/时间字符串
		//并将结果添加到给定的 String;多个参数的格式是StringBuffer
		//日期时间转换为字符串
		String sb2=sdf.format(date);
		System.out.println(sb2);
		//字符串转换为日期时间格式
		String str="2020年3月24日 10时58分21秒";
		//sdf:日期转换类.parse(时间字符串)
		Date date2=sdf.parse(str);
		//测试已经转换为了系统的日期.
		System.out.println(date2);


	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Car {
	//public:公共的；访问权限修饰符;用来设置类或属性、方法的访问范围；
	//1.属性：静态;public
	public String pinpai="大众甲壳虫";
	public double price;
	public String color;
	public int speedLimit;  //速度限制
	public boolean isSale;//是否卖了
	//2.行为：动态;
	//2.1打印信息;
	public void printInfo(){
		System.out.println("汽车品牌"+pinpai);
		System.out.println("汽车价格："+price);
		System.out.println("汽车颜色："+color);
		System.out.println("汽车速度："+speedLimit);
		System.out.println("汽车是否卖了？："+isSale);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TestCar {
	public static void main(String[] args) {
		//1.使用声明Car类的对象；叫car
		Car car;
		//2.new一下;在内存里面，分配地址;当new的时候，注：引用类型：默认为null
		//double：0.0;int等：0；也可以在定义的时候，赋值：相当于数据库的默认值;
		car=new Car();
		//3.赋值;对象.属性=值;
		car.pinpai="辉腾";
		car.price=3000000;
		car.speedLimit=60;
		car.color="紫色";
		car.isSale=true;
		//4.测试;		
		car.printInfo();
	}
}

1
2
3
4
5
6
7
8
public void printInfo(){
		System.out.println("汽车品牌"+pinpai);
		System.out.println("汽车价格："+price);
		System.out.println("汽车颜色："+color);
		System.out.println("汽车速度："+speedLimit);
		System.out.println("汽车是否卖了？："+isSale);
	}

1
2
3
4
public void fillGas(double sheng){
		System.out.println("汽车加了"+sheng+"升气");
	}

1
2
3
4
public String getName(){
		return name;
	}

1
2
3
4
5
6
7
public boolean isChao(int speed){
		if(speed<=speedLimit)
			return true;
		else
			return false;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class  Dog    //定义了一个Dog类
{
	//1.静态特征：属性
	//private:这个访问修饰符，是私有的，只能在类内访问
	//public:公共的，可以在类外访问,实际是有问题的
	public String name="旺财"; //字符串类型  变量名
	public String color="白色"; //颜色
	public int age=28;      //年龄

	//2.动态行为：方法
	//2.1 void:不返回任何类型 方法名
	public void printInfo(){
		System.out.println("狗名："+name);
		System.out.println("颜色："+color);
		System.out.println("年龄："+age);
	}
	//2.2 有参数 无返回值的方法,参数：food(食物)
	public void eat(String food){
		System.out.println(name+"吃"+food);
	}
	public void setName(String xingming){
		//this:代表当前对象;name:属性；xingming:参数
		this.name=xingming;
	}
	//2.3无参数 有返回类型的方法;
	public String getName(){
		return name;
	}
	//无参数就是()里面没有内容
	//有返回值就是方法前面有类型，不是void的
	//2.4有参数 有返回类型值的方法;自动狗，1 2 3,
	//狗会根据主人的指令，自动叫1 2 3次;
	public String shout(int num){
		String result="";
		for(int i=1;i<=num;i++){
			result+="汪";
		}
		return result;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Zoo  //定义一个动物园类 
{
	//动物园有大门;我们在使用的时候，只需要去运行含有main方法
	//类即可，java会自动把其他相关的类调用进行编译
	public static void main(String[] args) 
	{
		//关门放狗
		//Dog类是引用数据类型，除了基本数据类型之外，都是引用类型
		//引用数据类型的特征，就是可以被new,在内存分配空间
		//1.创建Dog类的一个对象dog,并且在内存进行分配空间
		Dog dog=new Dog();
		//2.给对象的属性赋值
		//dog.name="花花";
		dog.color="黄色";
		dog.age=7;
		//3.调用dog对象的方法
		dog.printInfo();
		dog.eat("骨头");
		dog.setName("滴滴");
		//dog.getName()返回类型就是String
		System.out.println(dog.getName());//println(字符串)
		//调用有参数  有返回值的方法;
		System.out.println(dog.getName()+"叫："+dog.shout(33));
	}
}

1
2
3
4
5
6
7
8
我是英雄，我的基本信息如下：
姓名:李小侠,生命值:300
我是武器，我的基本信息如下：
武器名：死神镰刀,攻击力：12
我是怪物，我的基本信息如下：
姓名:小龟,生命值:300,类型潜水类
李小侠需要砍25刀才能干掉小龟

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package chapter09;

public class Hero {
	public String name;
	public int level;
	
	public void say(){
		System.out.println(name+","+level);
	}
}

package com.aaa.www;
//chapter09包 
//com.aaa.www 外面的类

import chapter09.Hero;

public class TestGame {

	public static void main(String[] args) {
		Hero junjie=new Hero();
		junjie.name="奥利奥 ";
		junjie.level=222;
		junjie.say();
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class TestFinal {
	//1.定义变量：成员变量;属于类：TestFinal
//	final int i;//成为fianl类型常量;fianl修饰成员变量必须被初始化 
	final Integer MAX_VALUE=8844;
	final Integer TYPE=1;  //final常量：全部大写;
	
	public static void main(String[] args) {
		//局部变量：属于main（）
		int jj=2;
		TestFinal tf=new TestFinal();
		tf.say();
	}
	public void say(){
		final int jjj=2;
		//int i=2;如果存在成员变量和局部变量同名的情况，当调用包含局部变量的方法时候，优先调用局部变量。
		//System.out.println("i="+i);
//		jjj=222;//不能再次被赋值，因为是常量;
		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * 计算机类：自动出拳
 * 1:剪刀;2.石头;3.布;
 * @author teayear
 */
public class Computer {
	public String name;//名；
	public int score;//成绩
	public int value;//出拳值;
	//自动出拳;
	public void showFist(){
		//随机数：[1,3]
		int sjs=(int)(Math.random()*3)+1;
		this.value=sjs;	 //根据随机数产生的1 2 3，输出剪刀 石头  布 
		switch(sjs){
			case 1:System.out.println(this.name+"出拳：剪刀");break;
			case 2:System.out.println(this.name+"出拳：石头");break;
			case 3:System.out.println(this.name+"出拳：布");break;
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Scanner;

/**
 * 用户类
 * @author teayear
 */
public class Customer {
	public String name;  //玩家姓名
	public int score;  //成绩;
	public int value;  //出拳值;
	//出拳
	public void showFist(){
		Scanner input=new Scanner(System.in); //已经接受用户的输入;1 2 3
		int num;
		do{
			System.out.println("1、剪刀 2、石头 3、布(输入相应数字):");
			num=input.nextInt(); //hasNextInt();也可以加下;
			switch(num){
				case 1:System.out.println("你出拳：剪刀");break;
				case 2:System.out.println("你出拳：石头");break;
				case 3:System.out.println("你出拳：布");break;
				default:System.out.println("你的输入有误！");break;
			}
		}while(num<1 || num>4);
		this.value=num;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
import java.util.Scanner;
/**
 * 主游戏界面定义：
 * @author teayear
 */
public class Game {
	//1.属性;
	public Customer player;   //游戏主控类：玩家对象;
	public Computer computer;  //计算机对象;
	
	public int count;	//对局次数
	//用户输入对象input
	Scanner input=new Scanner(System.in);
	//2.1  欢迎方法;
	public void welcome(){
		System.out.println("********************************");
		System.out.println("*******      猜拳，开始           *******");
		System.out.println("********************************");
	}
	//2.2初始化方法;
	public void init(){
		computer=new Computer();
		player=new Customer();
		
		System.out.println("出拳规则：1、剪刀 2、石头 3、布");
		String compName="";
		System.out.print("请选择对方角色(1、刘备 2、孙权 3、曹操):");
		int num=input.nextInt();
		
		do{
			switch(num){
				case 1:compName="刘备";break;
				case 2:compName="孙权";break;
				case 3:compName="曹操";break;
				case 0:System.out.println("选择错误，请重新输入!");break;
			}
		}while(num<1 || num>4);
		
		computer.name=compName;
		//设置玩家姓名
		System.out.print("请输入你的姓名：");
		player.name=input.next();
		System.out.println(player.name+"  VS  "+computer.name+"  对战");
	}
	//2.3 开始游戏,可以先不写;
			public void play(){
				String answer=""; //定义变量：接受用户的输入，是否继续下一次游戏;
				System.out.println("要开始吗？(y/n):"); //是否开始;
				answer=input.next();
				do{
					//开始PK
					this.player.showFist();
					this.computer.showFist();
					
					int result=(player.value-computer.value);
					//success:1  3;3 2
					if(result==1 ||result==-2){
						System.out.println("^.^你太牛了,你胜出!");
						this.player.score++;
					}else if(result==0){
						System.out.println("平局");
					}else{
						System.out.println("不好意思哦 ，你失败啦!");
						this.computer.score++;
					}
					this.count++;	//总局数加1
					System.out.println("是否开始下一轮？(y/n):");
					answer=input.next();
				}while(answer.equals("y")||answer.equals("Y")); //当非y/Y的时候退出;
			}
			//结束游戏;
			public void report(){
				System.out.println(this.player.name+"   VS  "+this.computer.name);
				System.out.println("对战次数："+this.count+"平局次数："+(this.count-player.score-computer.score));
				System.out.println("***** 名字   分数*****");
				System.out.println(this.player.name+"ttt"+this.player.score);
				System.out.println(computer.name+"ttt"+this.computer.score);
			}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 测试游戏开始
 * @author teayear
 */
public class TestGame {
	public static void main(String[] args) {
		Game game=new Game();
		game.welcome();
		game.init();
		game.play();//代码逐步实现
		
		game.report();  //代码逐步实现，可以先不写该代码
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public int count;	//对局次数
//用户输入对象input
Scanner input=new Scanner(System.in);
//2.1  欢迎方法;
public void welcome(){
	System.out.println("********************************");
	System.out.println("*******      猜拳，开始           *******");
	System.out.println("********************************");
}
//2.2初始化方法;
public void init(){
	computer=new Computer();
	player=new Customer();
	
	System.out.println("出拳规则：1、剪刀 2、石头 3、布");
	String compName="";
	System.out.print("请选择对方角色(1、刘备 2、孙权 3、曹操):");
	int num=input.nextInt();
	
	do{
		switch(num){
			case 1:compName="刘备";break;
			case 2:compName="孙权";break;
			case 3:compName="曹操";break;
			case 0:System.out.println("选择错误，请重新输入!");break;
		}
	}while(num<1 || num>4);
	
	computer.name=compName;
	//设置玩家姓名
	System.out.print("请输入你的姓名：");
	player.name=input.next();
	System.out.println(player.name+"  VS  "+computer.name+"  对战");
}
//2.3 开始游戏,可以先不写;
		public void play(){
			String answer=""; //定义变量：接受用户的输入，是否继续下一次游戏;
			System.out.println("要开始吗？(y/n):"); //是否开始;
			answer=input.next();
			do{
				//开始PK
				this.player.showFist();
				this.computer.showFist();
				
				int result=(player.value-computer.value);
				//success:1  3;3 2
				if(result==1 ||result==-2){
					System.out.println("^.^你太牛了,你胜出!");
					this.player.score++;
				}else if(result==0){
					System.out.println("平局");
				}else{
					System.out.println("不好意思哦 ，你失败啦!");
					this.computer.score++;
				}
				this.count++;	//总局数加1
				System.out.println("是否开始下一轮？(y/n):");
				answer=input.next();
			}while(answer.equals("y")||answer.equals("Y")); //当非y/Y的时候退出;
		}
		//结束游戏;
		public void report(){
			System.out.println(this.player.name+"   VS  "+this.computer.name);
			System.out.println("对战次数："+this.count+"平局次数："+(this.count-player.score-computer.score));
			System.out.println("***** 名字   分数*****");
			System.out.println(this.player.name+"ttt"+this.player.score);
			System.out.println(computer.name+"ttt"+this.computer.score);
		}

1
2
3
4

## 4.测试题，程序入口

1
2