• JAVA基础（十）

    练习

    2. (1)定义一个ManKind类，包括

            成员变量int sex和int salary；

            方法void manOrWoman()：根据sex的值显示“man”(sex==1)或者“woman”(sex==0)；

            方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。

             (2)定义类Kids继承ManKind，并包括

                     成员变量int yearsOld；

                     方法printAge()打印yearsOld的值。

            (3)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问其父类                  的成员变量及方法。

    1. package com.xxx.exer;
    2.  
    3. public class ManKind {
    4. 	private int sex;
    5. 	private int salary;
    6. 	
    7. 	
    8. 	
    9. 	public ManKind() {
    10. 		
    11. 	}
    12. 	
    13. 	
    14.  
    15. 	public ManKind(int sex, int salary) {
    16. 		this.sex = sex;
    17. 		this.salary = salary;
    18. 	}
    19.  
    20.  
    21.  
    22. 	public void manOrWoman() {
    23. 		if(sex == 1) {
    24. 			System.out.println("man");
    25. 		}else {
    26. 			System.out.println("woman");
    27. 		}
    28. 	}
    29. 	
    30. 	public int getSex() {
    31. 		return sex;
    32. 	}
    33.  
    34. 	public void setSex(int sex) {
    35. 		this.sex = sex;
    36. 	}
    37.  
    38. 	public int getSalary() {
    39. 		return salary;
    40. 	}
    41.  
    42. 	public void setSalary(int salary) {
    43. 		this.salary = salary;
    44. 	}
    45.  
    46. 	public void employeed() {
    47. 		if(salary == 0) {
    48. 			System.out.println("no job");
    49. 		}else {
    50. 			System.out.println("job");
    51. 		}
    52. 	}
    53. 	
    54. }
    55.  
    1. package com.xxx.exer;
    2.  
    3. public class Kids extends ManKind{
    4. 	private int yearsOld;
    5. 	
    6. 	
    7. 	
    8. 	public Kids() {
    9. 		 
    10. 	}
    11.  
    12.  
    13.  
    14. 	public Kids(int yearsOld) {
    15. 		this.yearsOld = yearsOld;
    16. 	}
    17.  
    18.  
    19.  
    20. 	public int getYearsOld() {
    21. 		return yearsOld;
    22. 	}
    23.  
    24.  
    25.  
    26. 	public void setYearsOld(int yearsOld) {
    27. 		this.yearsOld = yearsOld;
    28. 	}
    29.  
    30.  
    31.  
    32. 	public void printAge() {
    33. 		System.out.println("I am " + yearsOld + " years old.");
    34. 	}
    35. }
    1. package com.xxx.exer;
    2.  
    3. public class KidsTest {
    4. 	public static void main(String[] args) {
    5. 		Kids someKid = new Kids(12);
    6. 		
    7. 		someKid.printAge();
    8. 		
    9. 		someKid.setSalary(0);
    10. 		someKid.setSex(1);
    11. 		
    12. 		someKid.employeed();
    13. 		someKid.manOrWoman();
    14. 	}
    15. }

    3. 根据下图实现类。在CylinderTest类中创建Cylinder类的对象，设置圆 柱的底面半径和高，并输出圆柱的体积。

    1. package com.xxx.exer1;
    2.  
    3. public class Circle {
    4. 	private double radius;
    5.  
    6. 	public Circle() {
    7. 		radius = 1.0;
    8. 	}
    9.  
    10. 	public double getRadius() {
    11. 		return radius;
    12. 	}
    13.  
    14. 	public void setRadius(double radius) {
    15. 		this.radius = radius;
    16. 	}
    17. 	
    18. 	public double findArea() {
    19. 		return Math.PI * radius * radius;
    20. 	}
    21. }
    1. package com.xxx.exer1;
    2.  
    3. public class Cylinder extends Circle{
    4. 	private double length;
    5.  
    6. 	public Cylinder() {
    7. 		length = 1.0;
    8. 	}
    9.  
    10. 	public double getLength() {
    11. 		return length;
    12. 	}
    13.  
    14. 	public void setLength(double length) {
    15. 		this.length = length;
    16. 	}
    17. 	
    18. 	public double findVolume() {
    19. 		return findArea() * length;
    20. 	}
    21. }
    1. package com.xxx.exer1;
    2.  
    3. public class CylinderTest {
    4. 	public static void main(String[] args) {
    5. 		Cylinder cy = new Cylinder();
    6. 		
    7. 		cy.setRadius(2.1);
    8. 		cy.setLength(3.4);
    9. 		System.out.println("圆柱的体积为：" + cy.findVolume());
    10. 		System.out.println("圆柱的底面积为：" + cy.findArea());
    11. 	}
    12. }

    Eclipse debug调试

    测试问题代码

    1. package com.xxx.java;
    2.  
    3.  
    4. public class DebugTest {
    5. 	public static void main(String[] args) {
    6. 		int i = 10;
    7. 		int j = 20;
    8. 		System.out.println("i = " + i + ", j = " + j);
    9. 		
    10. 		DebugTest test = new DebugTest();
    11. 		int max = test.getMax(i, j);
    12. 		
    13. 		System.out.println("max = " + max);
    14. 	}
    15.  
    16. 	private int getMax(int k, int m) {
    17. 		int max = 0;
    18. 		if (k < m) {
    19. 			max = k;
    20. 		} else {
    21. 			max = m;
    22. 		}
    23. 		return max;
    24. 	}
    25.  
    26. }

    代码没报错，但结果不对

    1. package com.xxx.java;
    2.  
    3.  
    4. public class DebugTest1 {
    5. 	
    6. 	public static void main(String[] args) {
    7. 		int[] arr = new int[] {1,2,3,4,5};
    8. 		System.out.println(arr);
    9. 		
    10. 		char[] arr1 = new char[] {'a','b','c'};
    11. 		System.out.println(arr1);
    12. 	}
    13. 	
    14. }

    打印char数组输出字符串，而不是地址值 

    debug界面

     

    双击代码行首位置添加断点（若断点不生效可以按ctrl+alt+b）

    第一个图标resume 恢复：执行完当前行所在断点的所有代码，进入下一个断点，如果没有就结束

    第三个图标Terminate：强行终止

    第五个图标step into跳入（F5）：进入当前行所调用的方法中

     第六个图标step over（F6）：执行完当前行的语句，进入下一行

    第七个图标step return跳回（F7）：执行完当前行所在的方法，进入下一行

    第八个图标drop to frame：回到当前行所在的方法的第一行

    debug后记得切换回javaee视图

    方法的重写(override/overwrite)

    定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。                  在程序执行时，子类的方法将覆盖父类的方法。

    要求：

            1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

            2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

                    如：父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void

                           父类被重写的方法的返回值类型是A类，则子类重写的方法的返回值类型可以是A                             类或A类的子类

                           父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类                             型必须是相同的基本数据类型

            3. 子类重写的方法使用的访问权限（权限修饰符）不能小于父类被重写的方法的访问权限

                    且子类不能重写父类中声明为private权限的方法

            4. 子类方法抛出的异常类型不能大于父类被重写方法的异常类型 

    注意：

            子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static          的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

    1. package com.xxx.java1;
    2.  
    3. public class Person {
    4. 	String name;
    5. 	int age;
    6. 	
    7. 	public Person() {
    8.  
    9. 	}
    10.  
    11. 	public Person(String name, int age) {
    12. 		this.name = name;
    13. 		this.age = age;
    14. 	}
    15. 	
    16. 	static void eat() {
    17. 		System.out.println("吃饭");
    18. 	}
    19. 	
    20. 	public void walk(int distance) {
    21. 		System.out.println("走了" + distance + "公里");
    22. 		show();
    23. 		eat();
    24. 	}
    25. 	
    26. 	private void show() {
    27. 		System.out.println("我是一个人");
    28. 	}
    29. 	
    30. 	public Object info() {
    31. 		return null;
    32. 	}
    33. 	
    34. 	public double info1() {
    35. 		return 0.0;
    36. 	}
    37. }
    1. package com.xxx.java1;
    2.  
    3. public class Student extends Person {
    4. 	String major;
    5.  
    6. 	public Student() {
    7.  
    8. 	}
    9.  
    10. 	public Student(String major) {
    11. 		this.major = major;
    12. 	}
    13. 	
    14. 	public void study() {
    15. 		System.out.println("学习，专业是：" + major);
    16. 	}
    17. 	
    18. 	public static void eat() {
    19. 		System.out.println("学生多吃有营养的食物");
    20. 	}
    21. 	
    22. 	public void show() {
    23. 		System.out.println("我是一个学生");
    24. 	}
    25. 	
    26. 	public String info() {
    27. 		return null;
    28. 	}
    29. 	
    30. 	//public int info1() {
    31. 	//	return 0;
    32. 	//}
    33. }
    1. package com.xxx.java1;
    2.  
    3. public class PersonTest {
    4. 	public static void main(String[] args) {
    5. 		Student s = new Student("计算机科学与技术");
    6. 		s.eat();
    7. 		s.walk(10);
    8. 		s.study();
    9. 	}
    10. }

    1.如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？(NO)

    2. 修改练习1.2中定义的类Kids，在Kids中重新定义employeed()方法，覆盖父类ManKind中定义的employeed()方法，输出“Kids should study and no job.”

    1. package com.xxx.exer;
    2.  
    3. public class Kids extends ManKind{
    4. 	private int yearsOld;
    5. 	
    6. 	
    7. 	
    8. 	public Kids() {
    9. 		 
    10. 	}
    11.  
    12.  
    13.  
    14. 	public Kids(int yearsOld) {
    15. 		this.yearsOld = yearsOld;
    16. 	}
    17.  
    18.  
    19.  
    20. 	public int getYearsOld() {
    21. 		return yearsOld;
    22. 	}
    23.  
    24.  
    25.  
    26. 	public void setYearsOld(int yearsOld) {
    27. 		this.yearsOld = yearsOld;
    28. 	}
    29.  
    30.  
    31.  
    32. 	public void printAge() {
    33. 		System.out.println("I am " + yearsOld + " years old.");
    34. 	}
    35. 	
    36. 	public void employeed() {
    37. 		System.out.println("Kids should study and no job.");
    38. 	}
    39. }

    权限修饰符Protected

    创建class时指定父类

    选择browse

     搜索并选择父类

     完成

    1. package com.xxx.java2;
    2.  
    3. public class Order {
    4. 	private int orderPrivate;
    5. 	int orderDefault;
    6. 	protected int orderProtected;
    7. 	public int orderPublic;
    8.  
    9. 	private void methodPrivate() {
    10. 		orderPrivate = 1;
    11. 		orderDefault = 2;
    12. 		orderProtected = 3;
    13. 		orderPublic = 4;
    14. 	}
    15.  
    16. 	void methodDefault() {
    17.  
    18. 	}
    19. 	
    20. 	protected void methodProtected() {
    21.  
    22. 	}
    23. 	
    24. 	public void methodPublic() {
    25.  
    26. 	}
    27. }
    1. package com.xxx.java2;
    2.  
    3. public class OrderTest {
    4. 	public static void main(String[] args) {
    5. 		Order order = new Order();
    6. 		
    7. 		order.orderDefault = 1;
    8. 		order.orderProtected = 2;
    9. 		order.orderPublic = 3;
    10. 		
    11. 		order.methodDefault();
    12. 		order.methodProtected();
    13. 		order.methodPublic();
    14. 		
    15. 		//在不同类无法使用private
    16. 		//order.orderPrivate = 0;
    17. 		//order.methodPrivate();
    18. 	}
    19. }
    1. package com.xxx.java3;
    2.  
    3. import com.xxx.java2.Order;
    4.  
    5. public class SubOrder extends Order {
    6. 	public void method() {
    7. 		orderProtected = 2;
    8. 		orderPublic = 3;
    9. 		
    10. 		methodProtected();
    11. 		methodPublic();
    12. 		
    13. 		//在不同包的子类中无法使用private和缺省
    14. 		//orderPrivate = 0;
    15. 		//orderDefault = 1;
    16. 		
    17. 		//methodPrivate();
    18. 		//methodDefault();
    19. 	}
    20. 	
    21. }
    1. package com.xxx.java3;
    2.  
    3. import com.xxx.java2.Order;
    4.  
    5. public class OrderTest {
    6. 	public static void main(String[] args) {
    7. 		Order order = new Order();
    8. 		
    9. 		order.orderPublic = 3;	
    10. 		order.methodPublic();
    11.  
    12. 		// 在不同包中，且不是子类无法使用private、缺省、protected
    13. 		// order.orderPrivate = 0;
    14. 		// order.orderDefault = 1;
    15. 		// order.orderProtected = 2;
    16. 		
    17. 		// order.methodPrivate();
    18. 		// order.methodDefault();
    19. 		// order.methodProtected();
    20. 	}
    21. }

    关键字：super

    在Java类中使用super来调用父类中的指定操作：

            super可用于访问父类中定义的属性

            super可用于调用父类中定义的成员方法

            super可用于在子类构造器中调用父类的构造器

    注意：

            尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员

            super的追溯不仅限于直接父类

            super和this的用法相像，this代表本类对象的引用，super代表父类的内存 空间的标识

    调用父类的构造器

    子类中所有的构造器默认都会访问父类中空参数的构造器

    当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一” ，且必须放在构造器的首行

    如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

    当在构造器首行既没有调用this（形参列表）也没有调用super（形参列表）默认调用super（）；

    1. package com.xxx.java3;
    2.  
    3. public class Person {
    4. 	String name;
    5. 	int age;
    6. 	int id = 1001;
    7. 	
    8. 	public Person() {
    9. 		System.out.println("子类默认调用");
    10. 	}
    11. 	
    12. 	public Person(String name) {
    13. 		this.name = name;
    14. 	}
    15. 	
    16. 	public Person(String name, int age) {
    17. 		this.name = name;
    18. 		this.age = age;
    19. 	}
    20. 	
    21. 	public void eat() {
    22. 		System.out.println("人吃饭");
    23. 	}
    24. 	
    25. 	public void walk() {
    26. 		System.out.println("人走路");
    27. 	}
    28. }
    1. package com.xxx.java3;
    2.  
    3. public class Student extends Person {
    4.  
    5. 	String major;
    6. 	int id = 1002;
    7.  
    8. 	public Student() {
    9. 		super();	//默认调用
    10. 	}
    11.  
    12. 	public Student(String major) {
    13. 		super();
    14. 		this.major = major;
    15. 	}
    16. 	
    17.  
    18. 	public Student(String name, int age,String major) {
    19. 		super(name,age);
    20. 		this.major = major;
    21. 	}
    22.  
    23. 	public void eat() {
    24. 		System.out.println("学生，多吃有营养的事物");
    25. 	}
    26.  
    27. 	public void study() {
    28. 		System.out.println("学生，学习知识");
    29. 		this.eat();
    30. 		super.eat();
    31. 	}
    32.  
    33. 	public void show() {
    34. 		System.out.println("name = " + this.name + " age = " + super.age);
    35. 		System.out.println("id = " + this.id);
    36. 		System.out.println("id = " + super.id);
    37. 	}
    38. }
    1. package com.xxx.java3;
    2.  
    3. public class SuperTest {
    4. 	public static void main(String[] args) {
    5. 		Student s = new Student();
    6. 		
    7. 		s.show();
    8. 		
    9. 		System.out.println();
    10. 		
    11. 		s.study();
    12. 		
    13. 		Student s1 = new Student("Tom",21,"IT");
    14. 		s1.show();
    15. 		
    16. 		Student s2 = new Student();
    17. 	}
    18. }

     

    子类对象实例化过程

    当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器直到调用了java,lang,object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。

    1、写一个名为 Account 的类模拟账户。该类的属性和方法如下图所示。该类包括的属性： 账号 id，余额 balance，年利率 annualInterestRate；包含的方法：访问器方法（getter 和 setter 方法），返回月利率的方法 getMonthlyInterest()，取款方法 withdraw()，存款方法 deposit()。

     写一个用户程序测试 Account 类。在用户程序中，创建一个账号为 1122、余额为 20000、 年利率 4.5%的 Account 对象。使用 withdraw 方法提款 30000 元，并打印余额。 再使用 withdraw 方法提款 2500 元，使用 deposit 方法存款 3000 元，然后打印余额和月利率。

    1. package com.xxx.exer2;
    2.  
    3. public class Account {
    4. 	private int id;	//账户
    5. 	private double balance;	//余额
    6. 	private double annualInterestRate;//年利率
    7. 	
    8. 	public Account(int id, double balance, double annualInterestRate) {
    9. 		super();
    10. 		this.id = id;
    11. 		this.balance = balance;
    12. 		this.annualInterestRate = annualInterestRate;
    13. 	}
    14.  
    15. 	public int getId() {
    16. 		return id;
    17. 	}
    18.  
    19. 	public void setId(int id) {
    20. 		this.id = id;
    21. 	}
    22.  
    23. 	public double getBalance() {
    24. 		return balance;
    25. 	}
    26.  
    27. 	public void setBalance(double balance) {
    28. 		this.balance = balance;
    29. 	}
    30.  
    31. 	public double getAnnualInterestRate() {
    32. 		return annualInterestRate;
    33. 	}
    34.  
    35. 	public void setAnnualInterestRate(double annualInterestRate) {
    36. 		this.annualInterestRate = annualInterestRate;
    37. 	}
    38. 	
    39. 	public double getMonthlyInterest() {
    40. 		return annualInterestRate / 12;
    41. 	}
    42. 	public void withdraw (double amount) {
    43. 		if(balance >= amount) {
    44. 			balance -= amount;		
    45. 			return;
    46. 		}
    47. 		System.out.println("余额不足");
    48. 	}
    49. 	public void deposit (double amount) {
    50. 		if(amount > 0) {
    51. 			balance += amount;
    52. 		}
    53. 	}
    54.  
    55. 	
    56. 	
    57. }

     

     2、创建 Account 类的一个子类 CheckAccount 代表可透支的账户，该账户中定义一个属性 overdraft 代表可透支限额。在 CheckAccount 类中重写 withdraw 方法，其算法如下：

    如果（取款金额<账户余额），

            可直接取款

    如果（取款金额>账户余额），

            计算需要透支的额度

            判断可透支额 overdraft 是否足够支付本次透支需要，如果可以

                    将账户余额修改为 0，冲减可透支金额

            如果不可以

                    提示用户超过可透支额的限额

    要求：写一个用户程序测试 CheckAccount 类。在用户程序中，创建一个账号为 1122、余 额为 20000、年利率 4.5%，可透支限额为 5000 元的 CheckAccount 对象。 使用 withdraw 方法提款 5000 元，并打印账户余额和可透支额。 再使用 withdraw 方法提款 18000 元，并打印账户余额和可透支额。 再使用 withdraw 方法提款 3000 元，并打印账户余额和可透支额。

    提示：

             （1） 子类 CheckAccount 的构造方法需要将从父类继承的 3 个属性和子类自己的属性全                         部初始化。

            （2） 父类Account的属性balance被设置为private，但在子类CheckAccount的withdraw 方                      法中需要修改它的值，因此应修改父类的 balance 属性，定义其为 protected。

    运行结果如下图所示

     

    1. package com.xxx.exer2;
    2.  
    3. public class AccountTest {
    4. 	public static void main(String[] args) {
    5. 		Account acct = new Account(1122,20000,0.045);
    6. 		
    7. 		acct.withdraw(30000);
    8. 		System.out.println("余额为：" + acct.getBalance());
    9. 		
    10. 		acct.withdraw(2500);
    11. 		System.out.println("余额为：" + acct.getBalance());
    12.  
    13. 		acct.deposit(3000);
    14. 		System.out.println("余额为：" + acct.getBalance());
    15.  
    16. 		System.out.println("月利率为:" + acct.getMonthlyInterest());
    17. 		System.out.println("***************************");
    18. 		
    19. 		CheckAccount c = new CheckAccount(1122,20000,0.045,5000);
    20. 		
    21. 		c.withdraw(5000);
    22. 		System.out.println("余额为：" + c.getBalance());
    23. 		System.out.println("可透支额度为：" + c.getOverdraft());
    24. 		
    25. 		c.withdraw(18000);
    26. 		System.out.println("余额为：" + c.getBalance());
    27. 		System.out.println("可透支额度为：" + c.getOverdraft());
    28. 		
    29. 		c.withdraw(3000);
    30. 		System.out.println("余额为：" + c.getBalance());
    31. 		System.out.println("可透支额度为：" + c.getOverdraft());
    32. 	}
    33. }
    1. package com.xxx.exer2;
    2.  
    3. public class CheckAccount extends Account {
    4. 	private double overdraft; //可透支限额
    5.  
    6. 	public CheckAccount(int id, double balance, double annualInterestRate, double overdraft) {
    7. 		super(id, balance, annualInterestRate);
    8. 		this.overdraft = overdraft;
    9. 	}
    10. 	
    11. 	
    12. 	public double getOverdraft() {
    13. 		return overdraft;
    14. 	}
    15.  
    16.  
    17. 	public void setOverdraft(double overdraft) {
    18. 		this.overdraft = overdraft;
    19. 	}
    20.  
    21.  
    22. 	@Override
    23. 	public void withdraw(double amount) {
    24. 		if(getBalance() >= amount) {
    25. 			super.withdraw(amount);
    26. 		}else if(overdraft >= amount - getBalance()){
    27. 			overdraft -= amount - getBalance();
    28. 			super.withdraw(getBalance());
    29. 		}else {
    30. 			System.out.println("超过可透支额度");
    31. 		}
    32. 	}
    33. }

    面向对象特征之三：多态性

    多态性，是面向对象中最重要的概念，在Java中的体现：

            对象的多态性：父类的引用指向子类的对象

                    可以直接应用在抽象类和接口上

    Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

            若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)

            多态情况下， “看左边” ：看的是父类的引用（父类中不具备子类特有的方法）

                                   “看右边” ：看的是子类的对象（实际运行的是子类重写父类的方法）

    注意：

            调用子类重写的方法称为——虚拟方法调用

            只能调用子类重写的方法，不能调用子类特有的方法

            对象的多态性只适用于方法，不适用于属性

    虚拟方法调用(Virtual Method Invocation)

    子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

    1. package com.xxx.java4;
    2.  
    3. public class Person {
    4. 	String name;
    5. 	int age;
    6. 	int id = 1001;
    7. 	
    8. 	public void eat() {
    9. 		System.out.println("人吃饭");
    10. 	}
    11. 	
    12. 	public void walk() {
    13. 		System.out.println("人走路");
    14. 	}
    15. }
    1. package com.xxx.java4;
    2.  
    3. public class Man extends Person {
    4. 	boolean isSomking;
    5. 	int id = 1002;
    6. 	
    7. 	public void earnMoney() {
    8. 		System.out.println("男人负责挣钱养家");
    9. 	}
    10. 	
    11. 	public void eat() {
    12. 		System.out.println("男人多吃肉");
    13. 	}
    14. 	
    15. 	public void walk() {
    16. 		System.out.println("男人走路");
    17. 	}
    18. }
    1. package com.xxx.java4;
    2.  
    3. public class Woman extends Person{
    4. 	boolean isBeauty;
    5. 	
    6. 	public void goShopping() {
    7. 		System.out.println("女人喜欢购物");
    8. 	}
    9. 	
    10. 	public void eat() {
    11. 		System.out.println("女人少吃减肥");
    12. 	}
    13. 	
    14. 	public void walk() {
    15. 		System.out.println("女人走路");
    16. 	}
    17. }
    1. package com.xxx.java4;
    2.  
    3. public class PersonTest {
    4. 	public static void main(String[] args) {
    5. 		Person p = new Person();
    6. 		p.eat();
    7. 		
    8. 		Man m = new Man();
    9. 		m.eat();
    10. 		m.age = 25;
    11. 		m.earnMoney();
    12. 		
    13. 		System.out.println("*******************");
    14. 		//多态性
    15. 		Person p1 = new Man();
    16. 		
    17. 		Person p2 = new Woman();
    18. 		
    19. 		p1.eat();	//执行子类重写的方法
    20. 		p1.walk();
    21. 		System.out.println(p1.id);
    22. 		
    23. 		//p1.earnMoney();
    24. 	}
    25. }
    1. package com.xxx.java4;
    2.  
    3. import java.sql.Connection;
    4.  
    5. public class AnimalTest {
    6. 	
    7. 	public static void main(String[] args) {
    8. 		AnimalTest a = new AnimalTest();
    9. 		
    10. 		a.func(new Dog());
    11. 		a.func(new Cat());
    12. 	}
    13. 	
    14. 	public void func(Animal animal) {
    15. 		animal.eat();
    16. 		animal.shout();
    17. 	}
    18. 	
    19. 	//如果没有多态性，则想执行main中的代码还得再创建两个方法
    20. //	public void func(Dog dog) {
    21. //		dog.eat();
    22. //		dog.shout();
    23. //	}
    24. //	
    25. //	public void func(Cat cat) {
    26. //		cat.eat();
    27. //		cat.shout();
    28. //	}
    29. }
    30.  
    31. class Animal{
    32. 	public void eat() {
    33. 		System.out.println("动物进食");
    34. 	}
    35. 	public void shout() {
    36. 		System.out.println("动物叫");
    37. 	}
    38. }
    39.  
    40. class Dog extends Animal{
    41. 	public void eat() {
    42. 		System.out.println("狗吃骨头");
    43. 	}
    44. 	public void shout() {
    45. 		System.out.println("狗叫");
    46. 	}
    47. }
    48.  
    49. class Cat extends Animal{
    50. 	public void eat() {
    51. 		System.out.println("猫吃鱼");
    52. 	}
    53. 	public void shout() {
    54. 		System.out.println("猫叫");
    55. 	}
    56. }
    57.  
    58. //举例二
    59. //class Order{
    60. //	public void method(Object obj) {
    61. //		
    62. //	}
    63. //}
    64.

  • 相关阅读:
    vue 使用canvas 详细教程
    蓝桥杯 使用sort排序（c++）
    Linux 部署Neo4j 并且创建自定义Service
    (几何) 凸包问题
    从0到1 手把手搭建spring cloud alibaba 微服务大型应用框架（六）（优化篇）开发篇-如何解决微服务开发环境请求实例转发到别人机器问题
    算法训练Day39 | LeetCode62. 不同路径；LeetCode63.不同路径II
    GPT最佳实践：五分钟打造你自己的GPT
    链路追踪。
    用户管理的小demo--登录校检
    原型和原型链
  • 原文地址：https://blog.csdn.net/m0_56413004/article/details/126086852