devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

头歌实践教学平台——Java面向对象之类和对象

作者：很楠不爱3 | 2024-05-16 02:51:17

赞

踩

头歌实践教学平台——Java面向对象之类和对象

目录

Java面向对象 - 封装、继承和多态的综合练习

封装、继承和多态进阶(一)

封装、继承和多态进阶(二)

封装、继承和多态进阶(三)

Java面向对象 - 封装、继承和多态

什么是封装，如何使用封装

什么是继承，怎样使用继承

super关键字的使用

方法的重写与重载

抽象类

final关键字的理解与使用

接口

什么是多态，怎么使用多态

Java面向对象 - 类与对象

什么是类，如何创建类

构造方法

选择题(一)        C        CD

This关键字

类与对象练习

static关键字

选择题(二)        D        EG        B

Java高级特性 - Java反射

了解 Class 对象

利用反射分析类的能力

在运行时使用反射分析对象

利用反射进行方法调用

Java面向对象 - 封装、继承和多态的综合练习

封装、继承和多态进阶(一)

  1. package case1;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Task1 {
  6. 	public static void main(String[] args) {
  7. 		Scanner sc = new Scanner(System.in);
  8. 		String dogName = sc.next();
  9. 		String dogSex = sc.next();
  10. 		String dogColor = sc.next();
  11. 		String catName = sc.next();
  12. 		String catSex = sc.next();
  13. 		double catWeight = sc.nextDouble();
  14. 		// 通过有参构造函数实例化Dog类对象dog
  15. 		// dog调用talk()方法
  16. 		// dog调用eat()方法
  17. 		/********* begin *********/
  18. 		Dog dog=new Dog (dogName,dogSex,dogColor);
  19.         dog.talk();
  20.         dog.eat();
  21. 		/********* end *********/
  22. 		// 通过有参构造函数实例化Cat类对象cat
  23. 		// cat调用talk()方法
  24. 		// cat调用eat()方法
  25. 		/********* begin *********/
  26. 		Cat cat=new Cat(catName,catSex,catWeight);
  27.         cat.talk();
  28.         cat.eat();
  29. 		/********* end *********/
  30. 	}
  31. }
  32.  
  33. // 抽象类Pet 封装属性name和sex
  34. // 构造函数初始化name和sex
  35. // 声明抽象方法talk()
  36. // 声明抽象方法eat()
  37. abstract class Pet {
  38. 	/********* begin *********/
  39.     public abstract void talk();
  40.     public abstract void eat();
  41.     private String name;
  42.     private String sex;
  43.     public String getname(){
  44.         return name;
  45.     }
  46.     public void setname(String name){
  47.         this.name=name;
  48.     }
  49.     public String getsex(){
  50.         return sex;
  51.     }
  52.     public void setsex(String sex){
  53.         this.sex=sex;
  54.     }
  55.     public Pet(String name,String sex){
  56.         this.name=name;
  57.         this.sex=sex;
  58.     }
  59. 	/********* end *********/
  60. }
  61.  
  62. // Dog类继承自Pet类 封装属性color
  63. // 构造函数初始化name、sex和color
  64. // 实现自己的talk()方法和eat()方法
  65. // talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
  66. // eat()输出'name吃骨头'
  67. class Dog extends Pet {
  68. 	/********* begin *********/
  69. 	private String color;
  70.     public String getcolor(){
  71.         return color;
  72.     }
  73.     public void setcolor(String color){
  74.         this.color=color;
  75.     }
  76.     public Dog(String name,String sex,String color){
  77.         super(name,sex);
  78.         sex=super.getname();
  79.         name=super.getname();
  80.         this.color=color;
  81.     }
  82.     public void talk(){
  83.         System.out.println("名称："+super.getname()+"，性别："+super.getsex()+"，颜色："+color+"，汪汪叫");
  84.     }
  85.     public void eat(){
  86.         System.out.println(super.getname()+"吃骨头！");
  87.     }
  88.     
  89. 	/********* end *********/
  90. }
  91.  
  92. // Cat类继承自Pet类 封装属性weight
  93. // 构造函数初始化name、sex和weight
  94. // 实现自己的talk()方法和eat()方法
  95. // talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
  96. // eat()输出'name吃鱼'
  97. class Cat extends Pet {
  98. 	/********* begin *********/
  99.     /********* begin *********/
  100. 	private double weight;
  101.     public double getweight(){
  102.         return weight;
  103.     }
  104.     public void setweight(double weight){
  105.         this.weight=weight;
  106.     }
  107.     public Cat(String name,String sex,double weight){
  108.     	 super(name,sex);
  109.          sex=super.getname();
  110.          name=super.getname();
  111.         this.weight=weight;
  112.     }
  113.     public void talk(){
  114.         System.out.println("名称："+super.getname()+"，性别："+super.getsex()+"，体重："+weight+"kg，喵喵叫");
  115.     }
  116.     public void eat(){
  117.         System.out.println(super.getname()+"吃鱼！");
  118.     }
  119.  
  120. 	/********* end *********/
  121.  
  122. }


封装、继承和多态进阶(二)

  1. package case2;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Task2 {
  6. 	public static void main(String[] args) {
  7. 		Scanner sc = new Scanner(System.in);
  8. 		String cName = sc.next();
  9. 		String cSex = sc.next();
  10. 		int cAge = sc.nextInt();
  11. 		String eName = sc.next();
  12. 		String eSex = sc.next();
  13. 		int eAge = sc.nextInt();
  14. 		// 创建测试类对象test
  15. 		// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
  16. 		// 通过showEat()方法调用Chinese的eat()方法
  17. 		// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
  18. 		// 通过showEat()方法调用English的eat()方法
  19. 		/********* begin *********/
  20.         Person person1=new Chinese(cName,cSex,cAge);
  21.         showEat (person1);
  22.         Person person2=new English(eName,eSex,eAge);
  23.         showEat (person2);
  24. 		/********* end *********/
  25. 		// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
  26. 		// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
  27. 		/********* begin *********/
  28.         Chinese chinese=(Chinese) person1;
  29.         chinese.shadowBoxing();
  30.         English english=(English) person2;
  31.         english.horseRiding();
  32. 		/********* end *********/
  33. 	}
  34.  
  35. 	// 定义showEat方法，使用父类作为方法的形参，实现多态，传入的是哪个具体对象就调用哪个对象的eat()方法
  36. 	/********* begin *********/
  37.     //题目中没有static 这里应该定义一个静态方法，如果不定义静态方法的话，上面showeat（对象）无法正常调用
  38.     public static void showEat(Person person){
  39.         person.eat();
  40.         
  41.     }
  42. 	/********* end *********/
  43. }
  44.  
  45. // 抽象类Person 封装属性name、sex和age
  46. // 构造函数初始化name、sex和age
  47. // 声明抽象方法eat()
  48. abstract class Person {
  49. 	/********* begin *********/
  50.     private String name;
  51.     private String sex;
  52.     private int age;
  53.     public String getname(){
  54.         return name;
  55.     }
  56.     public void setname(String name){
  57.         this.name=name;
  58.     }
  59.     public String getsex(){
  60.         return sex;
  61.     }
  62.     public void setsex(String sex){
  63.         this.sex=sex;
  64.     }
  65.     public int getage(){
  66.         return age;
  67.     }
  68.     public void setage(int age){
  69.         this.age=age;
  70.     }
  71.     public Person (String name,String sex,int age){
  72.         this.name=name;
  73.         this.sex=sex;
  74.         this.age=age;
  75.     }
  76.     public abstract void eat();//定义抽象方法  让子类实现
  77. 	/********* end *********/
  78. }
  79.  
  80. // Chinese类继承自Person类
  81. // 构造函数初始化name、sex和age
  82. // 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是中国人，我喜欢吃饭！'
  83. // 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳！'
  84. class Chinese extends Person {
  85. 	/********* begin *********/
  86.     public Chinese(String name,String sex,int age){
  87.         super(name,sex,age);
  88.         sex=super.getname();
  89.         name=super.getname();
  90.         age=super.getage();
  91.     }
  92.     public void eat(){     //实现抽象方法eat()  编写方法体
  93.         System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是中国人，我喜欢吃饭！");
  94.     }
  95.     public void shadowBoxing(){
  96.         System.out.println(super.getname()+"在练习太极拳！");
  97.     }
  98.     
  99.  
  100. 	/********* end *********/
  101. }
  102.  
  103. // English类继承自Person类
  104. // 构造函数初始化name、sex和age
  105. // 重写父类方法eat() 输出'姓名：name，性别：sex，年龄：age，我是英国人，我喜欢吃三明治!'
  106. // 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马！'
  107. class English extends Person {
  108. 	/********* begin *********/
  109.     public English(String name,String sex,int age){
  110.         super(name,sex,age);
  111.         sex=super.getname();
  112.         name=super.getname();
  113.         age=super.getage();
  114.     }
  115.     public void eat(){     //实现抽象方法eat()  编写方法体
  116.         System.out.println("姓名："+super.getname()+"，性别："+super.getsex()+"，年龄："+super.getage()+"，我是英国人，我喜欢吃三明治！");
  117.     }
  118.     public void horseRiding(){
  119.         System.out.println(super.getname()+"在练习骑马！");
  120.     }
  121. 	/********* end *********/
  122. }
  123.


封装、继承和多态进阶(三)

  1. package case3;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Task3 {
  6. 	public static void main(String[] args) {
  7. 		@SuppressWarnings("resource")
  8. 		Scanner sc = new Scanner(System.in);
  9. 		String pppName = sc.next();
  10. 		int pppAge = sc.nextInt();
  11. 		String bpName = sc.next();
  12. 		int bpAge = sc.nextInt();
  13. 		String ppcName = sc.next();
  14. 		int ppcAge = sc.nextInt();
  15. 		String bcName = sc.next();
  16. 		int bcAge = sc.nextInt();
  17. 		// 测试运动员(乒乓球运动员和篮球运动员)
  18. 		// 乒乓球运动员
  19. 		// 通过带参构造函数实例化PingPangPlayer对象ppp
  20. 		// 输出'name---age'
  21. 		// 分别调用sleep()、eat()、study()、speak()方法
  22. 		/********* begin *********/
  23.         PingPangPlayer ppp=new PingPangPlayer(pppName,pppAge);
  24.         System.out.println(pppName+"---"+pppAge);
  25.         ppp.sleep();
  26.         ppp.eat();
  27.         ppp.study();
  28.         ppp.speak();
  29. 		/********* end *********/
  30. 		System.out.println("----------------");
  31. 		// 篮球运动员
  32. 		// 通过带参构造函数实例化BasketballPlayer对象bp
  33. 		// 输出'name---age'
  34. 		// 分别调用sleep()、eat()、study()方法
  35. 		/********* begin *********/
  36.         BasketballPlayer bp=new BasketballPlayer(bpName,bpAge);
  37.         System.out.println(bpName+"---"+bpAge);
  38.         bp.sleep();
  39.         bp.eat();
  40.         bp.study();
  41. 		/********* end *********/
  42. 		System.out.println("----------------");
  43. 		// 测试教练(乒乓球教练和篮球教练)
  44. 		// 乒乓球教练
  45. 		// 通过带参构造函数实例化PingPangCoach对象ppc
  46. 		// 输出'name---age'
  47. 		// 分别调用sleep()、eat()、teach()、speak()方法
  48. 		/********* begin *********/
  49.         PingPangCoach ppc=new PingPangCoach(ppcName,ppcAge);
  50.         System.out.println(ppcName+"---"+ppcAge);
  51.         ppc.sleep();
  52.         ppc.eat();
  53.         ppc.teach();
  54.         ppc.speak();
  55. 		/********* end *********/
  56. 		System.out.println("----------------");
  57. 		// 篮球教练
  58. 		// 通过带参构造函数实例化BasketballCoach对象bc
  59. 		// 输出'name---age'
  60. 		// 分别调用sleep()、eat()、teach()方法
  61. 		/********* begin *********/
  62.         BasketballCoach bc=new BasketballCoach(bcName,bcAge);
  63.         System.out.println(bcName+"---"+bcAge);
  64.         bc.sleep();
  65.         bc.eat();
  66.         bc.teach();
  67. 		/********* end *********/
  68. 		System.out.println("----------------");
  69. 	}
  70. }
  71.  
  72. // 说英语接口 声明抽象方法speak()
  73. interface SpeakEnglish {
  74. 	/********* begin *********/
  75.     void speak();
  76. 	/********* end *********/
  77. }
  78.  
  79. // 定义人的抽象类Person 封装name和age
  80. // 无参构造函数
  81. // 有参构造函数初始化name和age
  82. // 定义具体方法sleep() 输出'人都是要睡觉的'
  83. // 抽象方法eat()（吃的不一样）
  84. abstract class Person {
  85. 	/********* begin *********/
  86.     private String name;
  87.     private int age;
  88.     public String getname(){
  89.         return name;
  90.     }
  91.     public void setname(String name){
  92.         this.name=name;
  93.     }
  94.     public int getage(){
  95.         return age;
  96.     }
  97.     public void setage(int age){
  98.         this.age=age;
  99.     }
  100.     public Person(String name,int age){
  101.         this.name=name;
  102.         this.age=age;
  103.     }
  104.     public void sleep(){
  105.         System.out.println("人都是要睡觉的");
  106.     }
  107.     abstract void eat();
  108. 	/********* end *********/
  109. }
  110.  
  111. // 定义运动员Player（抽象类）继承自Person类
  112. // 无参构造函数
  113. // 有参构造函数初始化name和age
  114. // 运动员学习内容不一样，抽取为抽象 定义抽象方法study()
  115. abstract class Player extends Person {
  116. 	/********* begin *********/
  117.     public Player(String name,int age){
  118.         super(name,age);
  119.         name=super.getname();
  120.         age=super.getage();
  121.     }
  122.     abstract void study();
  123. 	/********* end *********/
  124. }
  125.  
  126. // 定义教练Coach（抽象类）继承自Person类
  127. // 无参构造函数
  128. // 有参构造函数初始化name和age
  129. // 教练教的不一样 定义抽象方法teach()
  130. abstract class Coach extends Person {
  131. 	/********* begin *********/
  132.     public Coach(String name,int age){
  133.         super(name,age);
  134.         name=super.getname();
  135.         age=super.getage();
  136.     }
  137.     abstract void teach();
  138. 	/********* end *********/
  139. }
  140.  
  141. // 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类（兵乓球运动员需要说英语）
  142. // 无参构造函数
  143. // 有参构造函数初始化name和age
  144. // 实现自己的eat()方法 输出'乒乓球运动员吃大白菜，喝小米粥'
  145. // 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
  146. // 实现自己的speak()方法 输出'乒乓球运动员说英语'
  147. class PingPangPlayer extends Player implements SpeakEnglish {
  148. 	/********* begin *********/
  149.     public PingPangPlayer(String name,int age){
  150.         super(name,age);
  151.         name=super.getname();
  152.         age=super.getage();
  153.     }
  154.     public void eat(){
  155.         System.out.println("乒乓球运动员吃大白菜，喝小米粥");
  156.     }
  157.     public void study(){
  158.         System.out.println("乒乓球运动员学习如何发球和接球");
  159.     }
  160.     public void speak(){
  161.         System.out.println("乒乓球运动员说英语");
  162.     }
  163. 	/********* end *********/
  164. }
  165.  
  166. // 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口，因为他不需要说英语
  167. // 无参构造函数
  168. // 有参构造函数初始化name和age
  169. // 实现自己的eat()方法 输出'篮球运动员吃牛肉，喝牛奶'
  170. // 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
  171. class BasketballPlayer extends Player {
  172. 	/********* begin *********/
  173.     public BasketballPlayer(String name,int age){
  174.         super(name,age);
  175.         name=super.getname();
  176.         age=super.getage();
  177.     }
  178.     public void eat(){
  179.         System.out.println("篮球运动员吃牛肉，喝牛奶");
  180.     }
  181.     public void study(){
  182.         System.out.println("篮球运动员学习如何运球和投篮");
  183.     }
  184. 	/********* end *********/
  185. }
  186.  
  187. // 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类（兵乓球教练需要说英语）
  188. // 无参构造函数
  189. // 有参构造函数初始化name和age
  190. // 实现自己的eat()方法 输出'乒乓球教练吃小白菜，喝大米粥'
  191. // 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
  192. // 实现自己的speak()方法 输出'乒乓球教练说英语'
  193. class PingPangCoach extends Coach implements SpeakEnglish {
  194. 	/********* begin *********/
  195.     public PingPangCoach(String name,int age){
  196.         super(name,age);
  197.         name=super.getname();
  198.         age=super.getage();
  199.     }
  200.     public void eat(){
  201.         System.out.println("乒乓球教练吃小白菜，喝大米粥");
  202.     }
  203.     public void teach(){
  204.         System.out.println("乒乓球教练教如何发球和接球");
  205.     }
  206.     public void speak(){
  207.         System.out.println("乒乓球教练说英语");
  208.     }
  209. 	/********* end *********/
  210. }
  211.  
  212. // 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口，因为他不需要说英语
  213. // 无参构造函数
  214. // 有参构造函数初始化name和age
  215. // 实现自己的eat()方法 输出'篮球教练吃羊肉，喝羊奶'
  216. // 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
  217. class BasketballCoach extends Coach {
  218. 	/********* begin *********/
  219.     public BasketballCoach(String name,int age){
  220.         super(name,age);
  221.         name=super.getname();
  222.         age=super.getage();
  223.     }
  224.     public void eat(){
  225.         System.out.println("篮球教练吃羊肉，喝羊奶");
  226.     }
  227.     public void teach(){
  228.         System.out.println("篮球教练教如何运球和投篮");
  229.     }
  230. 	/********* end *********/
  231. }
  232.  
  233.

Java面向对象 - 封装、继承和多态

什么是封装，如何使用封装

  1. package case1;
  2. public class TestPersonDemo {
  3.     public static void main(String[] args) {
  4.         /********* begin *********/
  5.         // 声明并实例化一Person对象p
  6.         Person p = new Person();
  7.         // 给p中的属性赋值
  8.         p.setName("张三");
  9.         p.setAge(18);
  10.         // 调用Person类中的talk()方法
  11.         p.talk();
  12.         /********* end *********/
  13.     }
  14. }
  15. // 在这里定义Person类
  16. class Person {
  17.     /********* begin *********/
  18.     private String name;
  19.     private int age;
  20.     public String getName() {
  21.         return name;
  22.     }
  23.     public void setName(String name) {
  24.         this.name = name;
  25.     }
  26.     public int getAge() {
  27.         return age;
  28.     }
  29.     public void setAge(int age) {
  30.         this.age = age;
  31.     }
  32.     void talk() {
  33.         System.out.println("我是：" + name + "，今年：" + age + "岁");
  34.     }
  35.     /********* end *********/
  36. }


什么是继承，怎样使用继承

  1. package case2;
  2.  
  3. public class extendsTest {
  4.     public static void main(String args[]) {
  5.         // 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
  6.         /********* begin *********/
  7.           Cat cat= new Cat();
  8.           cat.name="大花猫";
  9.           cat.age=6;
  10.           cat.voice();
  11.           cat.eat();
  12.           System.out.println(cat.name+cat.age+"岁");
  13.         /********* end *********/
  14.  
  15.         // 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
  16.         /********* begin *********/
  17.          Dog dog= new Dog();
  18.           dog.name="大黑狗";
  19.           dog.age=8;
  20.           dog.voice();
  21.           dog.eat();
  22.           System.out.println(dog.name+dog.age+"岁");
  23.         /********* end *********/
  24.  
  25.     }
  26. }
  27.  
  28. class Animal {
  29.     /********* begin *********/
  30.      protected String name;
  31.      protected int age;
  32.  
  33.      public String getName(){
  34.        return name;
  35.      }
  36.      public void setName(String name){
  37.          this.name = name;
  38.      }
  39.  
  40.      public int getAge(){
  41.         return age;
  42.      }
  43.      public void setAge(int age){
  44.          this.age = age ;
  45.      }
  46.     /********* end *********/
  47.  
  48. }
  49.  
  50. class Cat extends Animal {
  51.     // 定义Cat类的voice()和eat()方法
  52.     /********* begin *********/
  53.      public void voice(){
  54.          System.out.println(name+"喵喵叫");
  55.      }
  56.      public void eat(){
  57.          System.out.println(name+"吃鱼");
  58.      }
  59.     /********* end *********/
  60. }
  61.  
  62. class Dog extends Animal {
  63.     // 定义Dog类的voice()和eat()方法
  64.     /********* begin *********/
  65.      public void voice(){
  66.          System.out.println(name+"汪汪叫");
  67.      }
  68.      public void eat(){
  69.          System.out.println(name+"吃骨头");
  70.      }
  71.     /********* end *********/
  72. }


super关键字的使用

  1. package case3;
  2.  
  3. public class superTest {
  4.     public static void main(String[] args) {
  5.         // 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
  6.         /********* begin *********/
  7.        Person p= new Person();
  8.        p.setName("张三");
  9.        p.setAge(18);
  10.        p.talk();
  11.        Student stu= new Student();
  12.       
  13.        stu.school="哈佛大学";
  14.        
  15.        System.out.println("，学校："+stu.school);
  16.  
  17.         /********* end *********/
  18.     }
  19. }
  20.  
  21. class Person {
  22.     /********* begin *********/
  23.      
  24.       private String name ;
  25.      private int age;
  26.  
  27.      public String getName(){
  28.          return name;
  29.      }
  30.  
  31.     public void setName(String name){
  32.         this.name= name;
  33.     }
  34.  
  35.      public int getAge(){
  36.          return age;
  37.      }
  38.  
  39.      public void setAge(int age){
  40.          this.age= age;
  41.      }
  42.  
  43.      public void talk(){
  44.          System.out.print("姓名："+name+"，年龄："+age);
  45.      }
  46.     /********* end *********/
  47. }
  48.  
  49. class Student extends Person {
  50.     /********* begin *********/
  51.     public String school;
  52.      public String getSchool(){
  53.          return school;
  54.      }
  55.  
  56.     public void setSchool(String name){
  57.         this.school= school;
  58.     }
  59.     /********* end *********/
  60. }


方法的重写与重载

  1. package case4;
  2.  
  3. public class overridingTest {
  4.     public static void main(String[] args) {
  5.         // 实例化子类对象s，调用talk()方法打印信息
  6.         /********* begin *********/
  7.         Student stu=new Student();
  8.         stu.talk("张三",18,"哈佛大学");
  9.         /********* end *********/
  10.         
  11.     }
  12. }
  13.  
  14. class Person {
  15.     /********* begin *********/
  16.       String name;
  17.       int age;
  18.       protected void talk(String name, int age){
  19.           this.name=name;
  20.           this.age=age;
  21.         System.out.print("我是："+this.name+"，今年："+this.age);
  22.       }  
  23.     /********* end *********/
  24. }
  25.  
  26. class Student extends Person {
  27.     /********* begin *********/
  28.  
  29.     String school;
  30.     
  31.     public void talk(String name,int age,String school){
  32.         
  33.             super.talk("张三",18);
  34.             
  35.         this.school=school;
  36.         System.out.println("岁，我在"+this.school+"上学");
  37.     }
  38.     /********* end *********/
  39. }


抽象类

  1. package case5;
  2.  
  3. public class abstractTest {
  4.     public static void main(String[] args) {
  5.         /********* begin *********/
  6.         // 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
  7.         Student stu=new Student("张三",20,"学生");
  8.         Worker wor=new Worker("李四",30,"工人");
  9.         // 分别调用各自类中被复写的talk()方法 打印信息。
  10.         stu.talk();
  11.         wor.talk();
  12.         /********* end *********/
  13.         
  14.     }
  15. }
  16.  
  17. // 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
  18. abstract class Person {
  19.     /********* begin *********/
  20.      protected String name;
  21.      protected int age;
  22.      protected String occupation;
  23.      Person(String name,int age,String occupation){
  24.          this.name=name;
  25.          this.age=age;
  26.          this.occupation=occupation;
  27.      }
  28.      abstract void talk();
  29.     /********* end *********/
  30. }
  31.  
  32. // Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
  33. class Student extends Person {
  34.     /********* begin *********/
  35.        
  36.        Student(String name,int age,String occupation) { 
  37.          super(name,age,occupation);
  38.        }
  39.      void talk(){
  40.          System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+ occupation+"！");
  41.      }
  42.     /********* end *********/
  43. }
  44.  
  45. // Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
  46. class Worker extends Person {
  47.     /********* begin *********/
  48.        
  49.         Worker(String name,int age,String occupation) { 
  50.          super(name,age,occupation);
  51.        }
  52.          
  53.      void talk(){
  54.          System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
  55.      }
  56.     /********* end *********/
  57.  
  58. }


final关键字的理解与使用

  1. package case6;
  2.  
  3. public class finalTest {
  4.     public static void main(String args[]) {
  5.         Bike1 obj = new Bike1();
  6.         obj.run();
  7.  
  8.         Honda honda = new Honda();
  9.         honda.run();
  10.  
  11.         Yamaha yamaha = new Yamaha();
  12.         yamaha.run();
  13.     }
  14. }
  15. //不可以修改 final 变量的值
  16. // final方法,不可以重写
  17.  
  18. class Bike1 {
  19.      int speedlimit = 90;
  20.  
  21.     void run() {
  22.         speedlimit = 120; 
  23.         System.out.println("speedlimit=120");
  24.     }
  25.  
  26. }
  27.  
  28. class Bike2 {
  29.      void run() {
  30.         System.out.println("running");
  31.     }
  32. }
  33.  
  34. class Honda extends Bike2 {
  35.     void run() { 
  36.         System.out.println("running safely with 100kmph");
  37.     }
  38.  
  39. }
  40.  
  41.  class Bike3 {
  42. }
  43.  
  44. class Yamaha extends Bike3 { 
  45.     void run() {
  46.         System.out.println("running safely with 100kmph");
  47.     }
  48.  
  49. }


接口

  1. package case7;
  2.  
  3. public class interfaceTest {
  4.     public static void main(String[] args) {
  5.         // 实例化一Student的对象s，并调用talk()方法，打印信息
  6.         /********* begin *********/
  7.          Student s =new Student();
  8.          s.talk();
  9.         /********* end *********/
  10.  
  11.     }
  12. }
  13.  
  14. // 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
  15. interface Person {
  16.     /********* begin *********/
  17.     String name="张三";
  18.     int age=18;
  19.     String occupation="学生";
  20.     abstract void talk();
  21.     /********* end *********/
  22. }
  23.  
  24. // Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
  25. class Student implements Person {
  26.     /********* begin *********/
  27.     public void talk(){
  28.         System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
  29.     }
  30.     /********* end *********/
  31. }


什么是多态，怎么使用多态

  1. package case8;
  2.  
  3. public class TestPolymorphism {
  4.     public static void main(String[] args) {
  5.         // 以多态方式分别实例化子类对象并调用eat()方法
  6.         /********* begin *********/
  7.         show(new Dog());
  8.         show(new Cat());
  9.         show(new Lion());
  10.         
  11.     }
  12.  
  13.     public static void show(Animal a){
  14.         a.eat();
  15.         if(a instanceof Dog){
  16.             
  17.         }else if(a instanceof Cat){
  18.             
  19.         }else{
  20.             
  21.         }
  22.     }
  23.         /********* end *********/
  24. }
  25.  
  26.  
  27. // Animal类中定义eat()方法
  28. abstract class Animal {
  29.     /********* begin *********/
  30.    abstract void eat();
  31.     /********* end *********/
  32. }
  33.  
  34. // Dog类继承Animal类 复写eat()方法
  35. class Dog extends Animal {
  36.     /********* begin *********/
  37.      public void eat() {
  38.         System.out.println("eating bread...");
  39.     }
  40.     /********* end *********/
  41. }
  42.  
  43. // Cat类继承Animal类 复写eat()方法
  44. class Cat extends Animal {
  45.     /********* begin *********/
  46.       public void eat() {
  47.         System.out.println("eating rat...");
  48.     }
  49.     /********* end *********/
  50. }
  51.  
  52. // Lion类继承Animal类 复写eat()方法
  53. class Lion extends Animal {
  54.     /********* begin *********/
  55.        public void eat() {
  56.         System.out.println("eating meat...");
  57.     }
  58.     /********* end *********/
  59. }

Java面向对象 - 类与对象

什么是类，如何创建类

  1.  
  2. package step1;
  3.  
  4. public class Test {
  5. 	public static void main(String[] args) {
  6. 		/********** Begin **********/
  7. 		//创建Dog对象
  8. 		//设置Dog对象的属性
  9. 		//在main方法中创建一个名为wuhuarou的Dog对象，
  10.         //并设置name为五花肉，color为棕色，variety为阿拉斯加。
  11. 		Dog wuhuarou = new Dog();
  12.         wuhuarou.name = "五花肉";
  13.         wuhuarou.color = "棕色";
  14.         wuhuarou.variety = "阿拉斯加";
  15. 		//输出小狗的属性
  16. 		System.out.println("名字：" +wuhuarou.name+ "，毛色：" +wuhuarou.color+ "，品种：" +wuhuarou.variety);
  17. 		
  18. 		//调用方法
  19.         wuhuarou.eat();
  20.         wuhuarou.run();
  21.  
  22. 		
  23. 		/********** End **********/
  24. 		
  25. 	}
  26. }
  27.  
  28. //在这里定义Dog类
  29. /********** Begin **********/
  30. class Dog{
  31.     String name;
  32.     String color;
  33.     String variety;
  34.     void eat(){
  35.         System.out.println("啃骨头");
  36.     }
  37.     void run(){
  38.         System.out.println("叼着骨头跑");
  39.     }
  40. }
  41.


构造方法

  1.  
  2. package step2;
  3.  
  4. import java.util.Scanner;
  5.  
  6. public class Test {
  7. 	public static void main(String[] args) {
  8. 		Scanner sc = new Scanner(System.in);
  9. 		String name = sc.next();
  10. 		String sex = sc.next();
  11. 		/********** Begin **********/
  12. 		//分别使用两种构造器来创建Person对象 
  13.         Person person1 = new Person();
  14.  
  15. 		Person person2 = new Person(name,sex);
  16.  
  17. 		/********** End **********/
  18. 		
  19. 	}
  20. }
  21.  
  22. //创建Person对象，并创建两种构造方法
  23. /********** Begin **********/
  24. class Person{
  25.     String name;
  26.     String sex;
  27.  
  28.     public Person(){
  29.         System.out.println("一个人被创建了");
  30.     }
  31.  
  32.  
  33.  
  34.     public Person(String name, String sex){
  35.         this.name = name;
  36.         this.sex = sex;
  37.         System.out.println("姓名："+name+'，'+"性别："+sex+'，'+"被创建了");
  38.     }
  39. }
  40.     
  41.  
  42. /********** End **********/
  43.  
  44.


选择题(一)        C        CD


This关键字

  1.  
  2. package step3;
  3.  
  4. import java.util.Scanner;
  5.  
  6. public class Test {
  7. 	public static void main(String[] args) {
  8. 		Scanner sc = new Scanner(System.in);
  9. 		String name = sc.next();
  10. 		int age = sc.nextInt();
  11. 		String sex = sc.next();
  12. 		Person p = new Person(name,age,sex);
  13. 		p.display();
  14. 	}
  15. }
  16.  
  17. class Person{
  18. 	String name = "张三";
  19. 	int age = 18; 
  20. 	String sex = "男";
  21. 	/********** Begin **********/
  22.  
  23. 	public Person(String name,int age,String sex){
  24. 		this(age);
  25. 		this.name = name;
  26. 		this.sex = sex;
  27. 	}
  28. 	
  29. 	public Person(int age){
  30. 		this.age = age;
  31. 	}
  32. 	
  33. 	public void display(){
  34. 		String name = "baby";
  35. 		int age = 45;
  36. 		String sex = "女";
  37. 		System.out.println("name：" + this.name);
  38. 		System.out.println("age：" + this.age);
  39. 		System.out.println("sex：" + this.sex);
  40. 	}
  41.  
  42.  
  43. 	/********** End **********/
  44. }
  45.


类与对象练习

  1.  
  2. package step5;
  3.  
  4. public class Test {
  5. 	/********** Begin **********/
  6. 	static String name = "楚留香";
  7. 	static
  8. 	{
  9. 		System.out.println("hello educoder");
  10. 	}
  11. 	public static void main(String[] args) {
  12. 		System.out.println("我叫" + name);
  13. 		study();
  14. 	}
  15. 	
  16. 	public static void study(){
  17. 		System.out.println("我喜欢在educoder上学习java");
  18. 	}
  19. 	/********** End **********/
  20. }
  21.


static关键字

  1.  
  2. package step5;
  3.  
  4. public class Test {
  5. 	/********** Begin **********/
  6. 	static String name = "楚留香";
  7. 	static
  8. 	{
  9. 		System.out.println("hello educoder");
  10. 	}
  11. 	public static void main(String[] args) {
  12. 		System.out.println("我叫" + name);
  13. 		study();
  14. 	}
  15. 	
  16. 	public static void study(){
  17. 		System.out.println("我喜欢在educoder上学习java");
  18. 	}
  19. 	/********** End **********/
  20. }
  21.


选择题(二)        D        EG        B

Java高级特性 - Java反射

了解 Class 对象

  1. package step1;
  2. /**
  3.  * 学员任务文件
  4.  */
  5. public class Reflect_stu {
  6.  
  7.     public static void main(String[] args) {
  8.         System.out.println("通过Object 类中的 getClass() 获取的 Class 对象为：" + getPersonClass1());
  9.         System.out.println("通过静态方法 Class.forName() 获取的 Class 对象为：" + getPersonClass2());
  10.         System.out.println("通过类字面常量获取 Class 的对象为：" + getPersonClass3());
  11.     }
  12.     /**
  13.      * 通过 Object 类中的 getClass() 获取的 Class 对象
  14.      *
  15.      * @return
  16.      */
  17.     public static Class getPersonClass1() {
  18.         /********** Begin *********/
  19. 		Person person = new Person();
  20. 		Class c = person.getClass();
  21.         return c;
  22.         /********** End *********/
  23.     }
  24.     /**
  25.      * 通过静态方法 Class.forName() 获取的 Class 对象
  26.      * <p>
  27.      * 注意：Person 类的全路径为: step1.Person
  28.      *
  29.      * @return
  30.      */
  31.     public static Class getPersonClass2() {
  32.         /********** Begin *********/
  33. 		Class c = null;
  34. 		String classname = "step1.Person";
  35. 		try{
  36. 			c = Class.forName(classname); //一个类的完整路径加名称
  37. 		}catch(ClassNotFoundException e){
  38. 		}
  39.         return c;
  40.         /********** End *********/
  41.     }
  42.     /**
  43.      * 通过类字面常量获取 Class 的对象
  44.      *
  45.      * @return
  46.      */
  47.     public static Class getPersonClass3() {
  48.         /********** Begin *********/
  49. 		Class c = Person.class;
  50.         return c;
  51.         /********** End *********/
  52.     }
  53. }


利用反射分析类的能力

  1. package step2;
  2.  
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  6. import java.lang.reflect.Modifier;
  7.  
  8. class Apple {
  9.     private String name;
  10.     public Apple(){}
  11.     public Apple(String name){}
  12.     public void setName(String name) {
  13.         this.name = name;
  14.     }
  15. }
  16. public class Reflect_stu {
  17.     public static void main(String[] args) {
  18.         // 请根据提供的 classPath 获取 step2.Apple 的 Class 对象， 请使用 Class.forName() 方法， 注意捕获异常
  19.         // 通关之后，你也可以修改 clasapath 为其他类路径，分析某个类的能力， 例如: java.util.Date
  20.         String classPath = "step2.Apple";
  21.         Class clazz = null;
  22.         /********** Begin *********/
  23. 		try{
  24. 			clazz = Class.forName(classPath);
  25. 		}catch(ClassNotFoundException e){	
  26. 		}
  27.         /********** End *********/
  28.         printFields(clazz);
  29.         printConstructors(clazz);
  30.         printMethods(clazz);
  31.     }
  32.   	/**
  33.      * 请打印类的每个域,输出格式为：修饰符 类型 变量名;
  34.      * @param clazz
  35.      */
  36.     public static void printFields(Class clazz) {
  37.         /********** Begin *********/
  38. 		Field[] f = clazz.getDeclaredFields();
  39. 		for(Field ff:f){
  40. 			Class type = ff.getType();
  41. 			int mod = ff.getModifiers();
  42. 			System.out.print(Modifier.toString(mod)+" ");
  43. 			System.out.print(type.getName()+" ");
  44. 			System.out.println(ff.getName()+";");
  45. 		}
  46.         /********** End *********/
  47.     }
  48.     /**
  49.      * 打印构造函数,输出格式为：修饰符 方法名称（参数）
  50.      * @param clazz
  51.      */
  52.     public static void printConstructors(Class clazz) {
  53.  		Constructor[] constructors = clazz.getDeclaredConstructors();
  54.         for (Constructor constructor : constructors) {
  55.             Class[] paramTypes = constructor.getParameterTypes();
  56.             /********** Begin *********/
  57.             String name = constructor.getName();
  58.             String modifiers = Modifier.toString(constructor.getModifiers());
  59.             if (modifiers.length() > 0) {
  60.                 System.out.print(modifiers + " ");
  61.             }
  62.             System.out.print(name + "(");
  63.             /********** End *********/
  64.             printParamTypes(paramTypes);
  65.         }
  66.     }
  67.     /**
  68.      * 请针对每个方法打印其签名，格式为：修饰符 返回值类型 方法名称(参数);
  69.      * @param clazz
  70.      */
  71.     public static void printMethods(Class clazz) {
  72.         Method[] methos = clazz.getDeclaredMethods();
  73.         for (Method method : methos) {
  74.             Class[] paramTypes = null;
  75.             /********** Begin *********/
  76. 			String name = method.getName();
  77.             Class returnType = method.getReturnType();
  78.             String modifiers = Modifier.toString(method.getModifiers());
  79.             System.out.print(modifiers+" "+returnType.getName() + " " + name + "(");
  80.             paramTypes = method.getParameterTypes();
  81.             /********** End *********/
  82.             printParamTypes(paramTypes);
  83.         }
  84.     }
  85.     /**
  86.      * 打印方法参数
  87.      * @param paramTypes
  88.      */
  89.     private static void printParamTypes(Class[] paramTypes) {
  90.         for (int j = 0; j < paramTypes.length; ++j) {
  91.             if (j > 0) {
  92.                 System.out.print(",");
  93.             }
  94.             System.out.print(paramTypes[j].getName());
  95.         }
  96.         System.out.println(");");
  97.     }
  98. }
  99.


在运行时使用反射分析对象

  1. package step3;
  2.  
  3. import java.lang.reflect.AccessibleObject;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Modifier;
  6.  
  7. public class Reflect_stu {
  8.     public static String toString(Object obj) {
  9.         Class cl = obj.getClass();
  10.         String r = "";
  11.         r += "[";
  12.         // 请获取所有 Field 并设置访问权限为 true
  13.         /********** Begin *********/
  14.         Field[] fields = cl.getDeclaredFields();
  15.         AccessibleObject.setAccessible(fields, true);
  16.         /********** End *********/
  17.         for (Field f : fields) {
  18.             // 此处 if，逻辑为判断 Field 域是否为非静态域
  19.             if (!Modifier.isStatic(f.getModifiers())) {
  20.                 if (!r.endsWith("[")) r += ",";
  21.                 r += f.getName() + "=";
  22.                 try {
  23.                     // 请获取域的类型及值
  24.                     /********** Begin *********/
  25.                     Class t = f.getType();
  26.                     Object val = f.get(obj);
  27.                     /********** End *********/
  28.                     // isPrimitive() 用于判断是否为基本数据类型，若为基础数据类型直接拼接，否则递归调用 toString 方法
  29.                     if (t.isPrimitive()) r += val;
  30.                     else r += toString(val);
  31.                 } catch (Exception e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }
  36.         r += "]";
  37.         return r;
  38.     }
  39.     public static void main(String[] args) {
  40.         Person person = new Person(88, 19, 175);
  41.         System.out.println(toString(person));
  42.     }
  43. }
  44. class Person {
  45.     public Integer weight;
  46.     private Integer age;
  47.     private Double height;
  48.     public Person(Integer weight, Integer age, double height) {
  49.         this.weight = weight;
  50.         this.age = age;
  51.         this.height = height;
  52.     }
  53. }


利用反射进行方法调用

  1. package step4;
  2.  
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.InvocationTargetException;
  5. import java.lang.reflect.Method;
  6.  
  7.  
  8. public class Reflect_stu {
  9.     public static void main(String[] args) throws InvocationTargetException {
  10.         //使用反射调用
  11.         Class clazz = null;
  12.         try {
  13.             clazz = Class.forName("step4.Apple");
  14.             /********** Begin *********/
  15.             Method setPriceMethod = clazz.getMethod("setPrice", double.class);
  16.             Constructor appleConstructor = clazz.getConstructor();
  17.             Object apple = appleConstructor.newInstance();
  18.             setPriceMethod.invoke(apple, 14);
  19.             Method getPriceMethod = clazz.getMethod("getPrice");
  20.             System.out.println(getPriceMethod.invoke(apple));
  21.             Method getTotal = clazz.getMethod("getTotal", double.class, int.class);
  22.             System.out.println(getTotal.invoke(apple, 20, 24));
  23.             /********** End *********/
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28.  
  29. }
  30. class Apple {
  31.     private double price;
  32.     private int count;
  33.     public Apple() {
  34.     }
  35.     public double getPrice() {
  36.         return price;
  37.     }
  38.  
  39.     public void setPrice(double price) {
  40.         this.price = price;
  41.     }
  42.  
  43.     public int getCount() {
  44.         return count;
  45.     }
  46.  
  47.     public void setCount(int count) {
  48.         this.count = count;
  49.     }
  50.  
  51.     public double getTotal(double price, int count) {
  52.         return price * count;
  53.     }
  54. }

如果此文章对你有帮助，麻烦点个赞哦~~~

点个关注，追新不迷路~，下一篇——Java面向对象之常用类

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/576450
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号