Java_练习代码（中）

最新推荐文章于 2024-03-24 21:40:32 发布

爱吃肉的羊呐

最新推荐文章于 2024-03-24 21:40:32 发布

阅读量417

点赞数 1

分类专栏： java基础 Java 文章标签： java 编程语言面向对象编程

本文链接：https://blog.csdn.net/qq_42735982/article/details/104323378

版权

Java 同时被 2 个专栏收录

14 篇文章 1 订阅

订阅专栏

java基础

11 篇文章 0 订阅

订阅专栏

/*
	方法重载：
		在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
		和返回值类型无关。
*/
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：数据类型[] 数组名;
			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：
		数据类型[][] 变量名 = 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]);
	}
}

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

	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}
	}
}

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

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

	第三步：把类用英文体现
		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("群发短信");
	}
}

/*
	一个.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();
	}
}

//手机类的定义
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();
	}
}

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

	由于我们创建了对象，所以我们可以通过对象去使用类中的成员。
	而现在的情况是，我们不想对象直接去使用类的成员变量。
	肿么办呢?
	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());
	}
}

/*
	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());
	}	
}

/*
	我们曾经说过，起名字，要做到见名知意，而现在的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());
	}	
}

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();
	}
}

/*
	定义一个员工类,自己分析出几个成员，
	然后给出成员变量，构造方法，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();
	}
}

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

	在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();
	}
}

/*
	需求：猜数字小游戏
	
	分析：
		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;
			}
		}
		
	}
}

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

	静态代码块：只执行一次。
	构造代码库：每次创建对象都执行。
*/
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();
	}
}

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

	学生类：
		成员变量：姓名，年龄
		成员方法：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();
	}
}

/*
	学生类和老师。定义两个功能(吃饭，睡觉)
*/
//学生类
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();
	}
}

/*
	方法重写：子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写
*/
//手机
/*
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("林青霞");
	}
}

/*
	猫：
		成员变量：姓名，年龄
		构造方法：无参，带参
		成员方法：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();
	}
}

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

	举例：
		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();
	}
}

//猫狗案例
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();
	}
}

/*
	接口概述：现在在动物园里面，有些猫可以钻火圈，狗跳高，做计算等东西。
			  而这些动作，并不是动物天生就就具备的，所以，不适合定义在动物类中。
			  并且，也不是所有的猫，或者狗具备这些功能，所以直接定义在猫或者狗类中也不合适。
			  针对这样的一种扩展功能，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) {
	
	}
}

//形式参数如果是基本类型，只需要传递该基本类型的值即可。
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);
	}
}

//返回值类型是接口，其实返回的是接口的实现类对象
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
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java_练习代码（中）

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

扫一扫