项目

内容

《面向对象程序设计（java）》

https://home.cnblogs.com/u/nwnu-daizh/

这个作业的要求在哪里

https://www.cnblogs.com/nwnu-daizh/p/11605051.html

作业学习目标
  1. 深入理解程序设计中算法与程序的关系；
  2. 深入理解java程序设计中类与对象的关系；
  3. 理解OO程序设计的第2个特征：继承、多态；
  4. 学会采用继承定义类设计程序（重点、难点）；
  5. 能够分析与设计至少包含3个自定义类的程序；
  6. 掌握利用父类定义子类的语法规则及对象使用要求。

随笔博文正文内容包括：

第一部分：总结第五章理论知识（30分）

一.继承：

　　用已有的类来构建新类的一种机制。当定义了一个新类继承了一个类时，这个类就继承了这个方法和域，同时在新类中添加新的方法和域以适应新情况。继承时Java程序设计中的一项核心技术，也是面向对象特征之一。

　  继承的优点：具有层次结构。子类继承父类的域和方法。 代码可重用性。父类的域和方法课用于子类。可以轻松定义子类。设计应用程序变得更加简单。

二.类、超类和子类：

　　1.定义子类：关键字extends表明正在构造的新类派生于一个已存在的类，已存在的类称为超类、基类或父类；新类称为子类、派生类或孩子类。子类比父类拥有的功能更加丰富。

　　在通过扩展超类定义子类的时候，仅需要指出子类与超类的不同之处。在设计类的时候，将通用的方法放在超类中，将具有特殊用途的方法放在子类中。

　　2.覆盖方法：在子类中可以增加域，增加方法或覆盖超类的方法，但绝对不能删除继承的任何域和方法。

　　3.子类构造器：如果子类的构造器没有显式地调用超类的构造器，则将自动地调用超类默认地构造器，如果超类没有不带参数地构造器，并且在子类的构造器中又没有显式地调用超类地其他构造器，则Java编译器将报告错误。

　　一个对象变量可以指示多种实际类型的现象被称为多态，在运行时能够自动地选择调用哪个方法地现象称为动态绑定。

　　this :1.引用隐式传参 2.调用类其他构造器

super:1.调用超类的方法 2.调用超类的构造器

　　使用super调用基类的方法

　　子类构造器会默认调用基类的无参构造来初始化基类的私有域，如果基类没有无参构造，则会报错

　　java中，不需要将方法声明为虚拟方法方法，基类指针指向不同对象时，虚拟指针知道指针指向的实际对象类型，所以能正确调用对应的方法，如果不希望让一个方法具有虚拟特征，可以标记为final

　　4.继承层次：继承并不仅限于一个层次，由一个公共超类派生出来的所有类的集合被称为继承层次，在继承层次中，从某个特定的类到其祖先的路径被称为该类的继承链。Java不支持多继承。

　　5.动态绑定、静态绑定和方法表：

　　编译器准确知道调用哪个方法的叫静态绑定(用private、static、final声明过的方法）

　　在运行时，调用方法依赖于实际类型并实现方法绑定(运行时可知)的叫动态绑定，虚拟机为基类和派生类生成一个方法表，虚拟机会在方法表中搜索最适合的方法进行调用。

　　动态绑定的优点就是：对程序进行拓展时，不需要重新对调用方法的代码进行重新编译，方法重写时，子类的方法的访问性不能低于基类方法。
　　6.阻止继承 final类  ：　
　　 final修饰的类不能被继承，final修饰的方法不能被覆盖，final修饰的域在构造方法内初始化，并且不能被改动。　　
　　被final修饰的类，其方法自动为final方法，但而不包括域。
　　动态绑定对系统开销很大，所以即时编译器会自动为没有被覆盖的类标记为内联函数，减少对系统的开销。
　　7.强制转换：
　　只能在继承层次内进行转换，将基类转换为子类之后，需判断是否转换成功 使用instanceof运算符检验。如果转换失败java不会生成一个空对象，而是抛出一个异常。
　　static_cast:基本数据类型转换。
　　const_cast:常量转化为非常量，或者反过来。
　　reinterpret_cast:任意类型转换而无须考虑安全和常量问题，不要轻易使用。
　　dynamic_cast:运行时转换，运行时要进行类型检查，存在继承关系之间（类中要有虚函数才能进行此转换,需检查类型信息，而类型信息保存在虚函数表中）。
　　8.抽象类与抽象方法
　　抽象类包含抽象方法也可以包含具体数据、具体方法。
　　类即时不含有抽象方法，也可以声明为抽象类。
　　抽象类不能被实例化。
　　9.受保护访问：
　　private:本类可见（也是c++初始化列表的原因，因为子类不可方位基类的private字段，需要调用基类的构造函数）
　　public:对所有类可见
　　protected:本包和所有子类可见（c++只对子类可见）
　　默认(无修饰符)：对本包可见
三.object：所有类的超类 ：
　　在java中,只有基本类型不是对象，其他类型（包括数组，枚举）都是对象，都扩展于超类
　    Object类是Java中所有类的祖先——每一个类都由它扩 展而来。在不给出超类的情况下，Java会自动把Object 作为要定义类的超类。 
        可以使用类型为Object的变量指向任意类型的对象。但 要对它们进行专门的操作都要进行类型转换。
　　equals方法：定义子类的equals方法时，可调用超类的equals方法。 super.equals（otherObject）
　　hashCode方法：Object类中的hashCode方法导出某个对象的散列 码。散列码是任意整数，表示对象的存储地址。 两个相等对象的散列码相等。
四.泛型数组列表：
　　利用ArrayList类，课允许程序在运行时确定数组的大小。
        ArrayList是一个采用类型参数的泛类型。
五.对象包装器与自动装箱：
　　每个基本类型都有之对应的类(对象包装类)
　　对象包装类不允许修改其中的值，同时也是final声明的
　　使用包装器声明变量时，其==表示其是否指向同一个对象，因此
　　两个对象包装器比较时调用equal方法

六.参数数量可变的方法
　　java 使用持有者类型(IntHolder、BooleanHold等)
　　可变参数 使用：public static double max(double... value)；实际上将若干参数绑定在数组中传递该max函数：public static void main(String... args)。
七.枚举类：
　　实际上是一个类，包含若干个实例，因此两个枚举类型的值比较，直接使用 == ，永远不要调用equal。 
　　所有的枚举类型都是Enum类的子类。所以他们继承了这个类的许多方法String toString() //返回枚举常量名
　　static Enum valueOf（Class enumClass,String name）//返回指定名字给定类的枚举常量
　　int ordinal() //返回在enum声明中枚举常量的索引 （从0 开始）
　　int compareTo(E other) //在枚举中的顺序比较
八.反射：
　　反射被大量用在javaBeans中。
　　反射的作用：
　　①在运行中分析类的能力
　　②在运行在查看类的对象
　　③实现通过的数组操作代码
　　④利用Method对象。

第二部分：实验部分

1、实验目的与要求

(1) 理解继承的定义；

(2) 掌握子类的定义要求

(3) 掌握多态性的概念及用法；

(4) 掌握抽象类的定义及用途。

2、实验内容和步骤

实验1：测试程序1（10分）

5-1程序代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package inheritance;
 
/**
 * This program demonstrates inheritance.
 * @version 1.21 2004-02-21
 * @author Cay Horstmann
 */
public class ManagerTest
{
   public static void main(String[] args)
   {
      // construct a Manager object   构造一个manager对象
      var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);  //将经理放到数组中去
      boss.setBonus(5000);   //由boss.setBonus单独设置津贴，其中setBonus是Manager的特有方法
 
      var staff = new Employee[3];     //定义一个包含三个雇员的数组
 
      // fill the staff array with Manager and Employee objects
 
      staff[0] = boss;        // 父类可以引用子类
      staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);   //将经理和雇员都放到数组中去
      staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);
 
      // print out information about all Employee objects
      for (Employee e : staff)     //for循环打印出各个雇员对象的信息
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

　　运行结果如下：

5-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
34
35
36
37
38
package inheritance;
 
import java.time.*;
 
public class Employee
{
   private String name;//private定义了一个只能在该类中访问的字符串常量
   private double salary;
   private LocalDate hireDay;
 
   public Employee(String name, double salary, int year, int month, int day)//定义变量
   {
      this.name = name;//将局部变量的值传递给成员变量
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);
   }//一个构造器，构造器与类同名
 
   public String getName()
   {
      return name;
   }//访问器
 
   public double getSalary()
   {
      return salary;
   }//访问器
 
   public LocalDate getHireDay()
   {
      return hireDay;
   }//访问器
 
   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }
}

　　程序运行结果如下：

5-3程序代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package inheritance;
 
public class Manager extends Employee    //由继承Employee类来定义Manager类的格式，关键字extend表示继承
{
   private double bonus;
 
   /**
    * @param name the employee's name
    * @param salary the salary
    * @param year the hire year
    * @param month the hire month
    * @param day the hire day
    */
   public Manager(String name, double salary, int year, int month, int day)
   {
      super(name, salary, year, month, day);    //调用超类Employee中含有这些参数的构造器
      bonus = 0;
   }
 
   public double getSalary()
   {
      double baseSalary = super.getSalary();    //用关键字super调用超类Employee中的getsalary方法
      return baseSalary + bonus;
   }
 
   public void setBonus(double b)
   {
      bonus = b;
   }
}

　　程序运行结果如下：

删除程序中Manager类、ManagerTest类，背录删除类的程序代码，在代码录入中理解父类与子类的关系和使用特点。

删除Manager类程序代码如下：

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
package inheritance;
 
public class Manager extends Employee    //由继承Employee类来定义Manager类的格式，关键字extend表示继承
{
   private double bonus;
 
   /**
    * @param name the employee's name
    * @param salary the salary
    * @param year the hire year
    * @param month the hire month
    * @param day the hire day
    */
   public Manager(String name, double salary, int year, int month, int day)
   {
      super(name, salary, year, month, day);    //调用超类Employee中含有这些参数的构造器
      bonus = 0;
   }
   @Override
   public double getSalary()
   {
      double baseSalary = super.getSalary();    //用关键字super调用超类Employee中的getsalary方法
      return baseSalary + bonus;
   }
 
   public void setBonus(double b)
   {
      bonus = b;
   }
}

　　删除ManagerTest类程序代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package inheritance;
 
/**
 * This program demonstrates inheritance.
 * @version 1.21 2004-02-21
 * @author Cay Horstmann
 */
public class ManagerTest
{
   public static void main(String[] args)
   {
      // construct a Manager object   构造一个manager对象
      var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);  //将经理放到数组中去
      boss.setBonus(5000);   //由boss.setBonus单独设置津贴，其中setBonus是Manager的特有方法
 
      var staff = new Employee[3];     //定义一个包含三个雇员的数组
 
      // fill the staff array with Manager and Employee objects
 
      staff[0] = boss;        // 父类可以引用子类
      staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);   //将经理和雇员都放到数组中去
      staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);
 
      // print out information about all Employee objects
      for (Employee e : staff)     //for循环打印出各个雇员对象的信息
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

　　程序运行结果如下:

实验1：测试程序2（10分）

5-4程序代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package abstractClasses;
 
/**
 * This program demonstrates abstract classes.
 * @version 1.01 2004-02-21
 * @author Cay Horstmann
 */
public class PersonTest
{
   public static void main(String[] args)
   {
      var people = new Person[2];   //定义一个包含2个雇员的数组
 
      // fill the people array with Student and Employee objects
      people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      people[1] = new Student("Maria Morris", "computer science");   //将雇员和学生的对象填充到Person引用数组
 
      // print out names and descriptions of all Person objects
      for (Person p : people)
         System.out.println(p.getName() + ", " + p.getDescription());   // 输出对象的姓名和信息描述
   }
}

　　程序运行结果如下：

5-5程序代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package abstractClasses;
 
public abstract class Person   // 使用abstract关键字
{
   public abstract String getDescription();   // 定义抽象类型person
   private String name;
 
   public Person(String name)
   {
      this.name = name;//将局部变量的值赋给成员变量
   }//为子类person类的构造器提供代码的构造器
   public String getName()
   {
      return name;    //Person类中还保存着姓名和一个返回姓名的方法
   }//构造器
}

　　程序运行结果如下：

5-6程序代码如下：

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
package abstractClasses;
 
import java.time.*;
 
public class Employee extends Person  //扩展了一个子类Person
{
   private double salary;
   private LocalDate hireDay;
 
   public Employee(String name, double salary, int year, int month, int day)//定义变量
   {
      super(name);
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);//hireday使用LocalDate的方法
   }
 
   public double getSalary()
   {
      return salary;
   }
 
   public LocalDate getHireDay()
   {
      return hireDay;
   }
 
   public String getDescription()
   {
      return String.format("an employee with a salary of $%.2f", salary);
   }
 
   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }
}

　　程序运行结果如下：

5-7程序代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package abstractClasses;
 
public class Student extends Person  //扩展了一个子类Student
{
   private String major;
 
   /**
    * @param name the student's name
    * @param major the student's major
    */
   public Student(String name, String major)
   {
      // pass name to superclass constructor
      super(name);
      this.major = major;   //将名称传递给超类构造函数
   }
 
   public String getDescription()
   {
      return "a student majoring in " + major;  //返回学生信息
   }
}

　　程序运行结果如下：

删除程序中Person类，PerTest类，背景录入删除类的程序代码，在代码录入中理解抽象类与子类的关系和使用特点。

删除Person类程序代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package abstractClasses;
 
public abstract class Person   // 使用abstract关键字
{
   public abstract String getDescription();   // 定义抽象类型person
   private String name;
 
   public Person(String name)
   {
      this.name = name;//将局部变量的值赋给成员变量
   }//为子类person类的构造器提供代码的构造器
   public String getName()
   {
      return name;    //Person类中还保存着姓名和一个返回姓名的方法
   }//构造器
}

　删除PersonTest类程序代码如下：　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package abstractClasses;
 
/**
 * This program demonstrates abstract classes.
 * @version 1.01 2004-02-21
 * @author Cay Horstmann
 */
public class PersonTest
{
   public static void main(String[] args)
   {
      var people = new Person[2];   //定义一个包含2个雇员的数组
 
      // fill the people array with Student and Employee objects
      people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      people[1] = new Student("Maria Morris", "computer science");   //将雇员和学生的对象填充到Person引用数组
 
      // print out names and descriptions of all Person objects
      for (Person p : people)
         System.out.println(p.getName() + ", " + p.getDescription());   // 输出对象的姓名和信息描述
   }
}

　　程序运行结果如下：

实验1：测试程序3（11分）

5-8程序代码如下：

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
package equals;
 
/**
 * This program demonstrates the equals method.
 * @version 1.12 2012-01-26
 * @author Cay Horstmann
 */
public class EqualsTest
{
   public static void main(String[] args)
   {
      var alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
      var alice2 = alice1;
      var alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
      var bob = new Employee("Bob Brandson", 50000, 1989, 10, 1);
 
      System.out.println("alice1 == alice2: " + (alice1 == alice2));
 
      System.out.println("alice1 == alice3: " + (alice1 == alice3));
 
      System.out.println("alice1.equals(alice3): " + alice1.equals(alice3));
 
      System.out.println("alice1.equals(bob): " + alice1.equals(bob));
 
      System.out.println("bob.toString(): " + bob);
 
      var carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      var boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
      boss.setBonus(5000);
      System.out.println("boss.toString(): " + boss);
      System.out.println("carl.equals(boss): " + carl.equals(boss));
      System.out.println("alice1.hashCode(): " + alice1.hashCode());
      System.out.println("alice3.hashCode(): " + alice3.hashCode());
      System.out.println("bob.hashCode(): " + bob.hashCode());
      System.out.println("carl.hashCode(): " + carl.hashCode());
   }
}

　　程序运行结果如下：

5-9程序代码如下：

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
package equals;
 
import java.time.*;
import java.util.Objects;
 
public class Employee
{
   private String name;//private定义了一个只能在该类中访问的字符串变量
   private double salary;
   private LocalDate hireDay;
//创建私有属性
   public Employee(String name, double salary, int year, int month, int day)
   {
      this.name = name;
      this.salary = salary;
      hireDay = LocalDate.of(year, month, day);
   }
 
   public String getName()
   {
      return name;
   }
 
   public double getSalary()
   {
      return salary;
   }
 
   public LocalDate getHireDay()
   {
      return hireDay;
   }//访问器
 
   public void raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }
 
   public boolean equals(Object otherObject)
   {
      // a quick test to see if the objects are identical  快速测试这些对象是否相同
      if (this == otherObject) return true;
 
      // must return false if the explicit parameter is null   如果显示参数为空，必须返回false
      if (otherObject == null) return false;
 
      // if the classes don't match, they can't be equal   如果第几个类不匹配，则他们不相同
      if (getClass() != otherObject.getClass()) return false;
 
      // now we know otherObject is a non-null Employee   //其他对象为非空Employee类
      var other = (Employee) otherObject;
 
      // test whether the fields have identical values   //测试是不是有相同值
      return Objects.equals(name, other.name)
         && salary == other.salary && Objects.equals(hireDay, other.hireDay);
   }
 
   public int hashCode()
   {
      return Objects.hash(name, salary, hireDay);
   }
 
   public String toString() //把其他类型的数据转换为字符串类型的数据
   {
      return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay="
         + hireDay + "]";
   }
}

　　程序运行结果如下：

5-10程序代码如下：

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
package equals;
 
public class Manager extends Employee  //扩展了一个子类Manager
{
   private double bonus; //创建一个私有属性
 
   public Manager(String name, double salary, int year, int month, int day)//定义变量
   {
      super(name, salary, year, month, day);//调用了父类的构造器
      bonus = 0;
   }
 
   public double getSalary()
   {
      double baseSalary = super.getSalary();//更改器
      return baseSalary + bonus;
   }
 
   public void setBonus(double bonus)
   {
      this.bonus = bonus;
   }
 
   public boolean equals(Object otherObject)
   {
      if (!super.equals(otherObject)) return false;
      var other = (Manager) otherObject;
      // super.equals checked that this and other belong to the same class  用super.equals检查这个类和其他类是否属于同一个类
      return bonus == other.bonus;
   }
 
   public int hashCode()
   {
      return java.util.Objects.hash(super.hashCode(), bonus);
   }
 
   public String toString()//吧其他类型的数据转换为字符串类型的数据
   {
      return super.toString() + "[bonus=" + bonus + "]";
   }
}

　　程序运行结果如下：

实验2：编程练习（20分）

程序代码如下：

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
import java.util.Scanner;
  
abstract class Shape {
    double PI = 3.14;
  
    public abstract double getPerimeter();
  
    public abstract double getArea();
}
  
class Rectangle extends Shape {
    int wide, len;
  
    Rectangle(int a, int b) {
        wide = a;
        len = b;
    }
  
    @Override
    public double getPerimeter() {
        // TODO Auto-generated method stub
        return 2 * (wide + len);
    }
  
    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        return wide * len;
    }
     
    public String toString(){
        return "[width=" + wide + ", length=" + len + "]";
    }
}
  
class Circle extends Shape {
    int radius;
  
    Circle(int _radius) {
        radius = _radius;
    }
  
    @Override
    public double getPerimeter() {
        // TODO Auto-generated method stub
        return radius * 2 * PI;
    }
  
    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        return radius * radius * PI;
    }
  
    public String toString(){
        return "[radius=" + radius + "]";
    }
  
}
  
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        in.nextLine();
        Shape A[] = new Shape[n];
        int k = 0, j = 0;
        double sumAllArea = 0, sumAllPerimeter = 0;
        for (int i = 0; i < n; i++) {
            String S = in.next();
            if (S.equals("rect")) {
                int wide = in.nextInt(), len = in.nextInt();
                in.nextLine();
                A[i] = new Rectangle(wide, len);
            } else if (S.equals("cir")) {
                int radius = in.nextInt();
                in.nextLine();
                A[i] = new Circle(radius);
            }
            sumAllArea += A[i].getArea();
            sumAllPerimeter += A[i].getPerimeter();
        }
  
        System.out.println(sumAllPerimeter);
        System.out.println(sumAllArea);
        System.out.print("[");
        for (int i = 0; i < n; i++) {
            if(i != 0)
                System.out.print(", ");
            if (A[i] instanceof Rectangle) {
                    System.out.print("Rectangle ");
                System.out.print(A[i].toString());
            }
            else {
                    System.out.print("Circle ");
                System.out.print(A[i].toString()); 
            }
        }
  
        System.out.println("]");
  
        for(int i = 0;i < n;i++) {
            if(A[i] instanceof Rectangle) {
                System.out.println("class Rectangle,class Shape");
            }else {
                System.out.println("class Circle,class Shape");
  
            }
        }
        in.close();
    }
}

　　程序运行结果如下：

3. 实验总结：（10分）

本次学习理解了Java程序设计中类与对象的关系，理解OO程序设计的特征：继承和多态，并学会采用继承定义类设计程序，掌握利用了父类定义子类的语法规则及对象使用要求。在完成实验过程中理解了继承的定义，掌握子类的定义要求，多态性的概念及用法，抽象类的定义及用途。通过自己动手敲代码让我更加深刻的理解了本章的知识。但本章知识比较多也比较重要，仍需要多多加强巩固，继续努力。

201871010115 马北 《面向对象程序设计（java)》 第6-7周学习总结的更多相关文章

  1. 201571030332 扎西平措 《面向对象程序设计Java》第八周学习总结

    <面向对象程序设计Java>第八周学习总结   项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https: ...

  2. 201771010118马昕璐《面向对象程序设计java》第八周学习总结

    第一部分:理论知识学习部分 1.接口 在Java程序设计语言中,接口不是类,而是对类的一组需求描述,由常量和一组抽象方法组成.Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个 ...

  3. 201771010134杨其菊《面向对象程序设计java》第十周学习总结

    第8章泛型程序设计学习总结 第一部分:理论知识 主要内容:   什么是泛型程序设计                   泛型类的声明及实例化的方法               泛型方法的定义      ...

  4. 201771010134杨其菊《面向对象程序设计java》第八周学习总结

    第八周学习总结 第一部分:理论知识 一.接口.lambda和内部类:  Comparator与comparable接口: 1.comparable接口的方法是compareTo,只有一个参数:comp ...

  5. 201771010134杨其菊《面向对象程序设计java》第七周学习总结

    第七周学习总结 第一部分:理论知识 1.继承是面向对象程序设计(Object Oriented Programming-OOP)中软件重用的关键技术.继承机制使用已经定义的类作为基础建立新的类定义,新 ...

  6. 201771010118 马昕璐《面向对象程序设计java》第十周学习总结

    第一部分:理论知识学习部分 泛型:也称参数化类型(parameterized type)就是在定义类.接口和方法时,通过类型参数 指示将要处理的对象类型. 泛型程序设计(Generic program ...

  7. 201871010126 王亚涛《面向对象程序设计 JAVA》 第十三周学习总结

      内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p/ ...

  8. 马凯军201771010116《面向对象程序设计Java》第八周学习总结

    一,理论知识学习部分 6.1.1 接口概念 两种含义:一,Java接口,Java语言中存在的结构,有特定的语法和结构:二,一个类所具有的方法的特征集合,是一种逻辑上的抽象.前者叫做“Java接口”,后 ...

  9. 周强201771010141《面向对象程序设计Java》第八周学习总结

    一.理论知识学习部分 Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个接口. 接口体中包含常量定义和方法定义,接口中只进行方法的声明,不提供方法的实现. 类似建立类的继承关系 ...

  10. 201777010217-金云馨《面向对象程序设计Java》第八周学习总结

    项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...

随机推荐

  1. 肖哥讲jquery：

    jquery 是一个模块 一个库 js封装的一个库 导入jq  <script src="jquery.js"></script>   <script ...

  2. php 学习笔记之关于时区的那点事

    科普一下什么是时区 众所周知,地球绕着太阳转的同时也会自转,因此同一时刻不同地区所接收到太阳照射的情况不同,所以有的地区是日出,有的地区是日落,还有的地区可能是黑夜. 既然地球上的不同地区时间不同,那 ...

  3. CF1278C-Berry Jam-（前缀和）

    https://vjudge.net/problem/CodeForces-1278C 题意:有2n瓶果酱,中间有一个楼梯隔开,从中间往左或右两边清空果酱,使得两种果酱的数量相等,最少要清空多少瓶 思 ...

  4. DRF--介绍和安装

    前后端不分离 在前后端不分离的应用模式中,前端页面看到的效果都是由后端控制,由后端渲染页面或重定向,也就是后端需要控制前端的展示,前端与后端的耦合度很高.这种应用模式比较适合纯网页应用,但是当后端对接 ...

  5. SQL查询--简单了解SQL(结构化查询语言)

    以下内容是从其他地方摘抄过来的哈,原文地址忘记了,当时把内容记在了笔记中 SQL分类: 数据查询语言(DQL) 数据定义语言(DDL) 数据操纵语言(DML) 数据控制语言(DCL) 1.数据查询语言 ...

  6. pycharm配置docker

  7. scss和sass最大的区别

    重新接触了一下sass语法,在vscode的用的easysass插件.ctrl+S就可以自动编译成css文件.需要自己配置生成css路径 遇到的一个坑就是sass官网几乎全是写的sass,示例中全部是 ...

  8. hdu-6071 Lazy Running

    In HDU, you have to run along the campus for 24 times, or you will fail in PE. According to the rule ...

  9. 转载一篇文章：LINQ TO SQL 大全

    https://www.cnblogs.com/chenwolong/p/lts.html 最近悟出来一个道理,在这儿分享给大家:学历代表你的过去,能力代表你的现在,学习代表你的将来. 十年河东十年河 ...

  10. js变量--全局变量和局部变量

    1.javaScript中在函数里声明的变量为局部变量,其余为全局变量. 2.javaScript没有块级元素