Java_练习代码（中）

/*
	方法重载：
		在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
		和返回值类型无关。
*/
class MethodDemo {
	public static void main(String[] args) {
		//需求：请写一个功能，实现两个数据的求和
		System.out.println(sum(10,20));

		//需求：请写一个功能，实现三个数据的求和
		//System.out.println(sum2(10,20,30));
		System.out.println(sum(10,20,30));

		System.out.println(sum(1.5,2.5));
	}

	public static int sum(int a,int b) {
		return a + b;
	}

	/*
	public static int sum2(int a,int b,int c) {
		return a + b + c;

		//方法的嵌套调用
		//return sum(sum(a,b),c);
	}
	*/

	//由于方法名要表达的其实是该方法的作用
	//所以，sum2这个名字不好，还是要用sum 比较好
	public static int sum(int a,int b,int c) {
		return a + b + c;
	}

	public static double sum(double a,double b) {
		return a + b;
	}
}
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

/*
	数组：存储同一种数据类型的多个元素的集合。(也可以称为容器)

	数组的定义格式：
		格式1：数据类型[] 数组名;
			int[] arr;
		格式2：数据类型 数组名[];
			int arr[];

		推荐方式1。

	现在的数组没有元素，使用是没有意义的。
	接下来，我们要对数组进行初始化。
	那么，我们如何对数组进行初始化呢?
		动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
		静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

	动态初始化：
		数据类型[] 数组名 = new 数据类型[数组长度];

*/
class ArrayDemo {
	public static void main(String[] args) {
		//按照动态初始化数组的格式，我们来定义一个存储3个int类型元素的数组
		int[] arr = new int[3];

		/*
			左边：
				int:说明数组中的元素的数据类型。
				[]:说明这是一个数组
				arr:数组的名称
			右边：
				new:为实体(对象)开辟内存空间
					Scanner sc = new Scanner(System.in);
				int:说明数组中的元素的数据类型。
				[]:说明这是一个数组
				3:说明的是数组中的元素个数
		*/

		//我们如何获取里面的值呢?
		//数组名称
		System.out.println(arr); //[I@778b3fee 地址值
		//如何获取元素值呢?
		//数组为每个元素分配了一个编号，这个编号的专业叫法：索引。
		//而且是从0开始编号的。也就是说数组的最大编号是长度-1。
		//有了编号以后，我们就可以通过数组名和编号的配合取得数组元素
		//格式：数组名[编号];
		System.out.println(arr[0]); //0
		System.out.println(arr[1]); //0
		System.out.println(arr[2]); //0
	}
}
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

/*
	二维数组：元素为一维数组的数组。

	定义格式1：
		数据类型[][] 变量名 = new 数据类型[m][n];
		
		m:m表示这个二维数组有多少个一维数组
		n:n表示每一个一维数组的元素个数

		变形：
			数据类型 变量名[][] = new 数据类型[m][n];
			数据类型[] 变量名[] = new 数据类型[m][n];

			int[] x,y[];
*/
class Array2Demo {
	public static void main(String[] args) {
		//定义一个二维数组
		int[][] arr = new int[3][2];
		//表示arr这个二维数组有三个元素
		//每个元素是一个一维数组
		//每一个一维数组有2个元素

		System.out.println(arr); //[[I@778b3fee
		System.out.println(arr[0]); //[I@57125f92
		System.out.println(arr[1]);
		System.out.println(arr[2]);

		//如何输出元素呢?
		System.out.println(arr[0][1]);
		System.out.println(arr[2][2]);
	}
}
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

/*
	看程序写结果，并总结基本类型和引用类型参数的传递问题(题目在备注部分)
		基本类型：形式参数的改变对实际参数没有影响。
		引用类型：形式参数的改变直接影响实际参数。

	java中有没有引用传递?
		java中只有值传递。
		地址值也是一个值。
*/
class ArgsDemo {
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		System.out.println("a:"+a+",b:"+b); //a:10,b:20
		change(a,b);
		System.out.println("a:"+a+",b:"+b); //a:?,b:?

		int[] arr = {1,2,3,4,5};
		change(arr);
		System.out.println(arr[1]); //?
	}

	public static void change(int a,int b)  //a=10,b=20
	{
		System.out.println("a:"+a+",b:"+b); //a:10,b:20
		a = b; //a=20;
		b = a + b; //b=40;
		System.out.println("a:"+a+",b:"+b); //a:20,b:40
	}

	public static void change(int[] arr) //arr = {1,2,3,4,5}
	{
		for(int x=0; x<arr.length; x++)
		{
			//如果是偶数，数据变为以前的2倍。
			if(arr[x]%2==0)
			{
				arr[x]*=2;
			}
		}

		//{1,4,3,8,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
33
34
35
36
37
38
39
40
41
42
43
44
45

/*
	第一步：分析事物
		手机事物：
			属性：品牌，价格，颜色
			行为：打电话，发短信

	第二步：把事物转换为类
		手机类：
			成员变量：品牌，价格，颜色
			成员方法：打电话，发短信

	第三步：把类用英文体现
		Phone:
			成员变量：brand，price，color
			成员方法：call(String name)，sendMessage()

	第四步：写代码体现
		成员变量：其实就是一个变量，只不过定义在类中方法外，并且也可以不给初始化值。
		成员方法：其实就是一个方法，只不过不需要static了。
*/
//这是我的手机类
class Phone {
	//品牌
	String brand;
	//价格
	int price;
	//颜色
	String color;

	//打电话的方法
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}

	//发短信的方法
	public void sendMessage() {
		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
34
35
36
37
38
39

/*
	一个.java文件中可以有多个类吗?
		可以。
	
	如果类用public修饰后，它应该修饰哪个类呢?
		修饰带main方法的。并且一个类中只应该有一个类被public修饰
		目前不写public修饰的。
	
	如何在测试类中使用一个类呢?
		创建对象使用类的成员
	如何创建对象呢?
		格式：
			类名 对象名 = new 类名();
	如何使用类的成员呢?
		成员变量：对象.变量名;
		成员方法：对象.方法名(...);

	注意：
		引用类型的默认值是null。
*/
class Student {
	//学号
	String sid;
	//姓名
	String name;
	//年龄
	int age;

	//学习的方法
	//学习的方法
	public void study() {
		System.out.println("学生爱学习");
	}

	//吃饭的方法
	public void eat() {
		System.out.println("学生要吃饭");
	}

	//睡觉的方法
	public void sleep() {
		System.out.println("学生想睡觉");
	}
}

class StudentDemo {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();

		//输出对象名
		System.out.println(s); //Student@1afb7ac7

		//输出成员变量
		System.out.println("学号是："+s.sid); //null
		System.out.println("姓名是："+s.name);//null
		System.out.println("年龄是："+s.age); //0
		System.out.println("--------------");

		//给成员变量赋值
		s.sid = "itcast001";
		s.name = "林青霞";
		s.age = 28;

		//再次输出成员变量
		System.out.println("学号是："+s.sid); //itcast001
		System.out.println("姓名是："+s.name);//林青霞
		System.out.println("年龄是："+s.age); //28
		System.out.println("--------------");

		//使用成员方法
		s.study();
		s.eat();
		s.sleep();
	}
}
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

//手机类的定义
class Phone {
	//品牌
	String brand;
	//价格
	int price;
	//颜色
	String color;

	//打电话的方法
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}

	//发短信
	public void sendMessage() {
		System.out.println("群发短信");
	}
}

class PhoneDemo {
	public static void main(String[] args) {
		//创建对象
		Phone p = new Phone();

		//使用成员变量
		System.out.println("品牌是："+p.brand);
		System.out.println("价格是："+p.price);
		System.out.println("颜色是："+p.color);
		System.out.println("----------------");

		//给成员变量赋值
		p.brand = "三星";
		p.price = 2999;
		p.color = "蓝色";

		//再次使用成员变量
		System.out.println("品牌是："+p.brand);
		System.out.println("价格是："+p.price);
		System.out.println("颜色是："+p.color);
		System.out.println("----------------");

		//调用成员方法
		//String name = "林青霞";
		//p.call(name);
		p.call("林青霞");
		p.sendMessage();
	}
}
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

/*
	定义学生类：姓名，年龄

	由于我们创建了对象，所以我们可以通过对象去使用类中的成员。
	而现在的情况是，我们不想对象直接去使用类的成员变量。
	肿么办呢?
	java针对这种情况，就提供了一个关键字：private。

	private:
		A:是一个权限修饰符。
		B:可以修饰成员(成员变量和成员方法)
		C:被private修饰的成员只在本类中才能访问。

*/
//定义学生类
class Student {
	String name;
	private int age;

	//因为年龄出现了负数，不符合现实情况
	//所以，我们要对年龄做出判断
	//而要做判断，就应该写判断语句
	//而写语句就应该在方法中
	public void checkAge(int a) {
		if(a<0 || a>100) {
			System.out.println("年龄有误");
		}else {
			age = a;
		}
	}

	public int getAge() {
		return age;
	}
}

//测试类
class StudentDemo {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();

		//给name和age赋值
		s.name = "林青霞";
		//s.age = 28;
		//s.age = -28;
		//通过方法赋值
		s.checkAge(-28);
		//s.age = -28;

		//输出
		//System.out.println(s.name+"***"+s.age);
		System.out.println(s.name);
		System.out.println(s.getAge());
	}
}
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

/*
	private的应用场景：
		a:把成员变量给私有化
		b:对外提供公共的getXxx()和setXxx()方法
*/
class Student {
	private String name;
	private int age;

	//针对name给出get和set方法
	public void setName(String n) {
		//我们在这里其实也是可以对name做一些判断的
		name = n;
	}

	public String getName() {
		return name;
	}

	//针对age给出get和set
	public void setAge(int a) {
		age = a;
	}

	public int getAge() {
		return age;
	}
}

class StudentDemo2 {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		//输出成员变量的值
		System.out.println(s.getName()+"---"+s.getAge());

		//给成员变量赋值
		s.setName("林青霞");
		s.setAge(28);

		//再次输出成员变量的值
		System.out.println(s.getName()+"---"+s.getAge());
	}	
}

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

/*
	我们曾经说过，起名字，要做到见名知意，而现在的n和a都不是一个好的变量名称。

	由于变量在查找的时候，采用的是就近原则，所以，这个时候，就产生了问题。
	本来想给成员变量赋值的，确赋值给了局部变量。
	那么，我们该如何解决这个问题呢?
	java针对这种情况，就提供了一个关键字：this

	this：代表本类的对象

	应用场景：
		局部变量隐藏成员变量
*/
class Student {
	private String name;
	private int age;

	/*
	public void setName(String n) {
		name = n;
	}
	*/

	public void setName(String name) {  //"林青霞"
		this.name = name;
	}

	public String getName() {
		return name; //其实这里隐含了this
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}
}

class StudentDemo {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		//输出成员变量的值
		System.out.println(s.getName()+"---"+s.getAge());

		//给成员变量赋值
		s.setName("林青霞");
		s.setAge(28);

		//再次输出成员变量的值
		System.out.println(s.getName()+"---"+s.getAge());
	}	
}

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

class Phone {
	private String brand;
	private int price;
	private String color;

	public Phone() {}

	public Phone(String brand,int price,String color) {
		this.brand = brand;
		this.price = price;
		this.color = color;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getBrand() {
		return brand;
	}

	public void setPrice(int price) {
		this.price = price;
	}

	public int getPrice() {
		return price;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public String getColor() {
		return color;
	}

	public void show() {
		System.out.println("我的手机是："+brand+",价格是："+price+",颜色是："+color);
	}
}
class PhoneTest {
	public static void main(String[] args) {
		//无参+setXxx()
		Phone p = new Phone();
		p.setBrand("三星");
		p.setPrice(1000);
		p.setColor("黑色");
		p.show();

		//带参
		Phone pp = new Phone("华为",799,"白色");
		pp.show();
	}
}

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

/*
	定义一个员工类,自己分析出几个成员，
	然后给出成员变量，构造方法，getXxx()/setXxx()方法，
	以及一个显示所有成员信息的方法。并测试。

	Employee：
		成员变量：员工编号,姓名,职位
		构造方法：无参，带参
		成员方法：getXxx()/setXxx()方法，show()
*/
class Employee {
	private String eid;
	private String name;
	private String job;

	public Employee() {}

	public Employee(String eid,String name,String job) {
		this.eid = eid;
		this.name = name;
		this.job = job;
	}

	public void setEid(String eid) {
		this.eid = eid;
	}

	public String getEid() {
		return eid;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setJob(String job) {
		this.job = job;
	}

	public String getJob() {
		return job;
	}

	public void show() {
		System.out.println("员工编号是："+eid+",姓名是："+name+",职位是："+job);
	}
}

class EmployeeDemo {
	public static void main(String[] args) {
		//无参
		Employee e = new Employee();
		e.setEid("kevin007");
		e.setName("周星驰");
		e.setJob("搞笑影视演员");
		e.show();

		//带参
		Employee e2 = new Employee("kevin003","刘德华","帅气影视演员");
		e2.show();
	}
}
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

/*
	班级编号应该是被班级每个人都共享的，所以定义一个就应该可以了。
	而姓名和年龄，每个人应该是不一样的，所以，每个对象，都应该定义自己的。

	在java中，用什么来表示成员变量是被共享的呢? static
*/
class Student {
	//姓名
	String name;
	//年龄
	int age;
	//班级编号
	//String classNumber;
	static String classNumber;

	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public Student(String name,int age,String classNumber) {
		this.name = name;
		this.age = age;
		this.classNumber = classNumber;
	}

	public void show() {
		System.out.println(name+"---"+age+"---"+classNumber);
	}
}

class StudentDemo {
	public static void main(String[] args) {
		//创建学生对象
		Student s1 = new Student("林青霞",28,"20150306");
		s1.show();

		/*
		Student s2 = new Student("马云",35,"20150306");
		s2.show();

		Student s3 = new Student("马化腾",33,"20150306");
		s3.show();
		*/
		Student s2 = new Student("马云",35);
		s2.show();

		Student s3 = new Student("马化腾",33);
		s3.show();
	}
}
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

/*
	需求：猜数字小游戏
	
	分析：
		A:系统产生一个1-100之间的随机数。
			int number = (int)(Math.random()*100)+1;
		B:键盘录入数据,用Scanner实现
		C:用这两个数据进行比较
			大	提示大了
			小	提示小了
			等	恭喜你，猜中了
		D:为了保证我们能够猜中，我们就加入循环，实现多次猜。直到猜中。
*/
import java.util.Scanner;

class GuessNumberDemo {
	public static void main(String[] args) {
		//系统产生一个1-100之间的随机数。
		int number = (int)(Math.random()*100)+1;

		while(true) {
			//键盘录入数据,用Scanner实现
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入一个数据：(1-100)");
			int guessNumber = sc.nextInt();

			//用这两个数据进行比较
			if(guessNumber > number) {
				System.out.println("你猜的数据"+guessNumber+"大了");
			}else if(guessNumber < number) {
				System.out.println("你猜的数据"+guessNumber+"小了");
			}else {
				System.out.println("恭喜你，猜中了");
				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
29
30
31
32
33
34
35
36
37
38
39
40

/*
	执行过程：静态代码库 --> 构造代码块 --> 构造方法 --> 局部代码块

	静态代码块：只执行一次。
	构造代码库：每次创建对象都执行。
*/
class Student {
	static {
		System.out.println("AAAAA");
	}

	{
		System.out.println("BBBBB");
	}

	public Student() {
		{
			System.out.println("CCCCC");
		}
	}

	static {
		System.out.println("DDDDD");
	}

	{
		System.out.println("EEEEE");
	}
}
class CodeTest {
	public static void main(String[] args) {
		Student s = new Student();
		Student ss = new Student();
	}
}
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

/*
	学生类和老师。定义两个功能(吃饭，睡觉)

	学生类：
		成员变量：姓名，年龄
		成员方法：getXxx()/setXxx(),eat(),sleep()
	老师类：
		成员变量：姓名，年龄
		成员方法：getXxx()/setXxx(),eat(),sleep()

	提取出共性的东西定义到一个类中：
	人类：
		成员变量：姓名，年龄
		成员方法：getXxx()/setXxx(),eat(),sleep()

	学生类 继承 人类
	老师类 继承 人类

	继承的好处：
		A:提高了代码的复用性
		B:提高了代码的维护性
		C:让类与类之间产生了关系，是多态的前提

	继承的弊端：类的耦合性很强
		设计原则：低耦合，高内聚。
		耦合：类与类的关系。
		内聚：自己完成事情的能力。
*/
//人类
class Person {
	private String name;
	private int age;

	public Person() {}

	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public void eat() {
		System.out.println("吃饭");
	}

	public void sleep() {
		System.out.println("睡觉");
	}
}
//学生类
class Student extends Person  {
	public Student() {}

	/*
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	*/
}

//老师类
class Teacher extends Person {
}

class PersonDemo {
	public static void main(String[] args) {
		//学生类
		Student s = new Student();
		s.setName("王祖贤");
		s.setAge(27);
		System.out.println(s.getName()+"---"+s.getAge());
		s.eat();
		s.sleep();
		System.out.println("--------------------------");

		//老师类
		Teacher t = new Teacher();
		t.setName("王祖蓝");
		t.setAge(25);
		System.out.println(t.getName()+"---"+t.getAge());
		t.eat();
		t.sleep();
	}
}
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

/*
	学生类和老师。定义两个功能(吃饭，睡觉)
*/
//学生类
class Student {
	private String name;
	private int age;

	public Student() {}

	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public void eat() {
		System.out.println("吃饭");
	}

	public void sleep() {
		System.out.println("睡觉");
	}
}
//老师类
class Teacher {
	private String name;
	private int age;

	public Teacher() {}

	public Teacher(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public void eat() {
		System.out.println("吃饭");
	}

	public void sleep() {
		System.out.println("睡觉");
	}
}
//测试类
class Test {
	public static void main(String[] args) {
		//测试学生
		Student s = new Student();
		s.setName("林青霞");
		s.setAge(28);
		System.out.println(s.getName()+"---"+s.getAge());
		s.eat();
		s.sleep();
		System.out.println("-------------------------");

		Student s2 = new Student("张曼玉",18);
		System.out.println(s2.getName()+"---"+s2.getAge());
		s2.eat();
		s2.sleep();
		System.out.println("-------------------------");

		//测试老师
		Teacher t = new Teacher();
		t.setName("风清扬");
		t.setAge(31);
		System.out.println(t.getName()+"---"+t.getAge());
		t.eat();
		t.sleep();
		System.out.println("-------------------------");

		Teacher t2 = new Teacher("令狐冲",21);
		System.out.println(t2.getName()+"---"+t2.getAge());
		t2.eat();
		t2.sleep();
	}
}
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

/*
	方法重写：子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写
*/
//手机
/*
class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

//新款手机
class NewPhone {
	public void call(String name) {
		System.out.println("听彩铃");
		System.out.println("给"+name+"打电话");
	}
}

class PhoneDemo {
	public static void main(String[] args) {
		//手机
		Phone p = new Phone();
		p.call("林青霞");
		System.out.println("-----------");
	
		//新手机
		NewPhone np = new NewPhone();
		np.call("林青霞");
	}
}
*/

class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

class NewPhone extends Phone {
	public void call(String name) {
		System.out.println("听彩铃");
		//System.out.println("给"+name+"打电话");
		super.call(name);
	}
}

class PhoneDemo {
	public static void main(String[] args) {
		//手机
		Phone p = new Phone();
		p.call("林青霞");
		System.out.println("-----------");
	
		//新手机
		NewPhone np = new NewPhone();
		np.call("林青霞");
	}
}
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

/*
	猫：
		成员变量：姓名，年龄
		构造方法：无参，带参
		成员方法：getXxx()/setXxx()，show()，catchMouse()
	狗：
		成员变量：姓名，年龄
		构造方法：无参，带参
		成员方法：getXxx()/setXxx()，show()，lookDoor()
	测试类：
		main(String[] args):
*/
//猫类
class Cat {
	private String name;
	private int age;

	public Cat() {}

	public Cat(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public void show() {
		System.out.println(name+"---"+age);
	}

	public void catchMouse() {
		System.out.println("猫捉老鼠");
	}
}
//狗类
class Dog {
	private String name;
	private int age;

	public Dog() {}

	public Dog(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public void show() {
		System.out.println(name+"---"+age);
	}

	public void lookDoor() {
		System.out.println("狗可以看门");
	}
}
//测试类
class Test {
	public static void main(String[] args) {
		//猫类测试
		Cat c = new Cat();
		c.setName("加菲猫");
		c.setAge(3);
		c.show();
		c.catchMouse();
		System.out.println("------------");
		Cat cc = new Cat("tom猫",6);
		cc.show();
		cc.catchMouse();
		System.out.println("------------");

		//练习1：自己写出狗的测试
		Dog d = new Dog();
		d.setName("啸天");
		d.setAge(5);
		d.show();
		d.lookDoor();
		System.out.println("------------");

		Dog dd = new Dog("旺财",8);
		dd.show();
		dd.lookDoor();
	}
}


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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

/*
	多态：同一个对象在不同时刻表现出现的不同状态。

	举例：
		A:水(水，冰，水蒸气)

		B:猫和动物。
			把右边的值赋值给左边，如果能读通过，就说明可以。
			动物 d = new 动物();
			动物 dd = new 猫();
			猫 m = new 猫();
			猫 mm = new 动物();  错误

			动物 dd = new 猫();

	代码如何体现呢?
		A:有继承关系	
		B:有方法重写	
		C:有父类引用指向子类对象
*/
class Animal {
	public void eat() {
		System.out.println("动物吃饭");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("狗吃肉");
	}
}

class DuoTaiDemo {
	public static void main(String[] args) {
		//Animal a = new Animal();
		//Dog d = new Dog();

		//多态
		Animal a = new Dog();
	}
}
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 Animal {
	private String name;
	private int age;

	public Animal() {}

	public Animal(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public void show() {
		System.out.println("name:"+name+",age:"+age);
	}

	public void sleep() {
		System.out.println("sleep");
	}

	public void eat() {
		System.out.println("eat");
	}
}

class Dog extends Animal {
	public Dog() {}

	public Dog(String name,int age) {
		super(name,age);
	}

	public void eat() {
		System.out.println("dog eat");
	}

	public void sleep() {
		System.out.println("dog sleep");
	}
}

class Cat extends Animal {
	public Cat() {}

	public Cat(String name,int age) {
		super(name,age);
	}

	public void eat() {
		System.out.println("cat eat");
	}

	public void sleep() {
		System.out.println("cat sleep");
	}
}

class AnimalDemo {
	public static void main(String[] args) {
		//测试Animal
		Animal a = new Animal();
		a.setName("动物");
		a.setAge(10);
		a.eat();
		a.sleep();
		a.show();
		System.out.println("------------");

		Animal a2 = new Animal("动物",10);
		a2.eat();
		a2.sleep();
		a2.show();
		System.out.println("------------");

		//测试Dog
		Dog d = new Dog();
		d.setName("大黄");
		d.setAge(5);
		d.eat();
		d.sleep();
		d.show();
		System.out.println("------------");

		Dog d2 = new Dog("大黄",5);
		d2.eat();
		d2.sleep();
		d2.show();
		System.out.println("------------");

		//练习1：测试Cat你们自己练习
		Cat c = new Cat();
		c.setName("大花猫");
		c.setAge(2);
		c.eat();
		c.sleep();
		c.show();
		System.out.println("------------");

		Cat c2 = new Cat("大花猫",2);
		c2.eat();
		c2.sleep();
		c2.show();
		System.out.println("------------");

		//通过Dog测试多态
		Animal aa = new Dog();
		aa.setName("小黄");
		aa.setAge(3);
		aa.eat();
		aa.sleep();
		aa.show();
		System.out.println("------------");

		Animal aa2 = new Dog("小黄",3);
		aa2.eat();
		aa2.sleep();
		aa2.show();
		System.out.println("------------");

		//练习2：通过Cat测试多态你们自己练习
		Animal aa3 = new Cat("小花猫",1);
		aa3.eat();
		aa3.sleep();
		aa3.show();
		System.out.println("------------");

		Animal aa4 = new Cat();
		aa4.setName("小花猫");
		aa4.setAge(1);
		aa4.eat();
		aa4.sleep();
		aa4.show();
	}
}
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

/*
	接口概述：现在在动物园里面，有些猫可以钻火圈，狗跳高，做计算等东西。
			  而这些动作，并不是动物天生就就具备的，所以，不适合定义在动物类中。
			  并且，也不是所有的猫，或者狗具备这些功能，所以直接定义在猫或者狗类中也不合适。
			  针对这样的一种扩展功能，java就提供了接口来体现。

	接口的特点：
		A:接口用关键字interface表示
			格式：interface 接口名 {}
		B:类实现接口用implements表示
			格式：class 类名 implements 接口名 {}
		C:接口不能实例化
			接口多态。
		D:接口的子类
			a:要么是抽象类
			b:要么重写接口中的所有的抽象方法
*/
interface Animal {
	public abstract void show();
}

abstract class Dog implements Animal {
}

class Cat implements Animal {
	public void show() {}
}

class InterfaceDemo {
	public static void main(String[] args) {
	
	}
}
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 Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}

class ArgsDemo {
	public static void main(String[] args) {
		Demo d = new Demo();

		//变量
		int x = 10;
		int y = 20;
		int z = d.sum(x,y);

		//常量
		int a = d.sum(10,20);

		System.out.println(z);
		System.out.println(a);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//返回值类型是接口，其实返回的是接口的实现类对象
interface Person {
	public abstract void study();
}

class PersonDemo {
	public Person getPerson() {
		return new Student();
	}
}

class Student implements Person {
	public void study() {
		System.out.println("好好学习，天天向上");
	}
}

class ReturnDemo3 {
	public static void main(String[] args) {
		//PersonDemo pd = new PersonDemo();
		//Person p = pd.getPerson();
		//p.study();
		
		//链式编程
		new PersonDemo().getPerson().study();
	}
}
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

扫面二维码关注，可获得全部练习代码！