201771010101 白玛次仁 《2018面向对象程序设计(Java)》第七周学习总结

Posted baimaciren

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了201771010101 白玛次仁 《2018面向对象程序设计(Java)》第七周学习总结相关的知识,希望对你有一定的参考价值。

实验七 继承附加实验

实验时间 2018-10-11

1. 继承的概念:

继承在本职上是特殊——一般的关系,即常说的is-a关系。子类继承父类,表明子类是一种特殊的父类,并且具有父类所不具有的一些属性或方法。

2. 继承中的初始化顺序:

从类的结构上而言,其内部可以有如下四种常见形态:属性(包括类属性和实例属性)、方法(包括类方法和实例方法)、构造器和初始化块(包括类的初始化块和实例的初始化块)。对于继承中的初始化顺序,又具体分为类的初始化和对象的初始化。

类初始化:

jvm装载类的准备阶段,首先为类的所有类属性和类初始化块分配内存空间。并在类首次初始化阶段中为其进行初始化,类属性和类初始化块之间的定义时的顺序决定了其初始化的顺序。若类存在父类,则首先初始化父类的类属性和类初始化块,一直上溯到Object类最先执行。

对象初始化:

new创建对象时,首先对对象属性和初始化块分配内存,并执行默认初始化。如果存在父类,则先为父类对象属和初始化块先分配内存并执行初始化。然后执行父类构造器中的初始化程序,接着才开始对子类的对象属性和初始化块执行初始化。

注:

1. 在对象初始化阶段,属性和方法均针对子类可以从父类继承过来的属性和方法而言,一般而言,都是针对父类中非private而言的。因为private修饰的为父类所特有的,子类没有继承过来,当new子类时,无须为其分配空间并执行初始化。当然了,父类的构造器子类也是不继承过来的,但构造器另当别论。

2. 类的初始化只执行一次,当对同一个类new多个对象时,类属性和类初始化块只初始化一次。

3.继承中的隐藏:

隐藏含义:实际上存在,但是对外不可见。

Java类具有三种访问控制符:private、protected和public,同时当不写这三个访问控制符时,表现为一种默认的访问控制状态。因此,一共具有四种访问控制级别。

具体访问控制表现如下:

private修饰的属性或方法为该类所特有,在任何其他类中都不能直接访问;

default修饰的属性或方法具有包访问特性,同一个包中的其他类可以访问;

protected修饰的属性或方法在同一个中的其他类可以访问,同时对于不在同一个包中的子类中也可以访问;

public修饰的属性或方法外部类中都可以直接访问。

当子类继承父类,子类可以继承父类中具有访问控制权限的属性和方法(一般来说是非private修饰的),对于private修饰的父类所特有的属性和方法,子类是不继承过来的。

当子类需要改变继承过来的方法时,也就是常说的重写父类的方法。一旦重写后,父类的此方法对子类来说表现为隐藏。以后子类的对象调用此方法时,都是调用子类重写后

的方法,但子类对象中想调用父类原来的此方法时,可以通过如下两种方式:

1.将子类对象类型强制转化为父类类型,进行调用;

2.通过super调用。

同样的,如果在子类中定义父类中相同名称的属性时,父类属性在子类中表现为隐藏。

4.继承中的this和super:

构造器中的this表示当前正在初始化的对象引用,方法中的this表示当前正在调用此方法的对象引用。this具体用法表现在一下几个方面:

1.当具多个重载的构造器时,且一个构造器需要调用另外一个构造其,在其第一行使用this(param)形式调用,且只能在第一行;

2.当对象中一个方法需要调用本对象中其他方法时,使用this作为主调,也可以不写,实际上默认就是this作为主调;

3.当对象属性和方法中的局部变量名称相同时,在该方法中需要显式的使用this作为主调,以表示对象的属性,若不存在此问题,可以不显式的写this。

其实,其牵涉到的一个问题就是变量的查找规则:先局部变量 => 当前类中定义的变量 => 其父类中定义的可以被子类继承的变量 => 父类...

super表示调用父类中相应的属性和方法。在方法中,若需要调用父类的方法时,也一定要写在第一行

5. 继承与组合:

从单纯的实现效果上看,继承和组合都能达到同样的目的。并且都是实现代码复用的有效方式。但在一般性的概念层次中,两者具有较为明显的差别。

继承表现为一般——特殊的关系,子类是一个特殊的父类,是is-a的关系。父类具有所有子类的一般特性。

组合表现为整体——部分关系,即has-a关系。在组合中,通过将“部分”单独抽取出来,形成自己的类定义,并且在“整体”

这个类定义中,将部分定义为其中的一个属性,并通过get和set方法,以此可以调用“部分”类中的属性和方法。

1、实验目的与要求

1)进一步理解4个成员访问权限修饰符的用途; 

2)掌握Object类的常用API用法;

3)掌握ArrayList类用法与常用API

4)掌握枚举类使用方法;

5)结合本章知识,理解继承与多态性两个面向对象程序设计特征,并体会其优点;

6)熟练掌握Java语言中基于类、继承技术构造程序的语法知识(ch1-ch5)

7)利用已掌握Java语言程序设计知识,学习设计开发含有1个主类、2个以上用户自定义类的应用程序。

2、实验内容和步骤

实验1  补充以下程序中主类内main方法体,以验证四种权限修饰符的用法。

public class TEST1 {

private String t1 = "这是TEST1的私有属性";

public String t2 = "这是TEST1的公有属性";

protected String t3 = "这是TEST1受保护的属性";

String t4 = "这是TEST1的默认属性";

private void tese1() {

System.out.println("我是TEST1private修饰符修饰的方法");

}

public void tese2() {

System.out.println("我是TEST1public修饰符修饰的方法");

}

protected void tese3() {

System.out.println("我是TEST1protected修饰符修饰的方法");

}

void tese4() {

System.out.println("我是TEST1无修饰符修饰的方法");

}

}

public class TEST2 extends TEST1{

private String e1 = "这是TEST2的私有属性";

public String e2 = "这是TEST2的公有属性";

protected String e3 = "这是TEST2受保护的属性";

String e4 = "这是TEST2的默认属性";

public void demo1() {

System.out.println("我是TEST2public修饰符修饰的方法");

}

private void demo2() {

System.out.println("我是TEST2private修饰符修饰的方法");

}

protected void demo3() {

System.out.println("我是TEST2protected修饰符修饰的方法");

}

void demo4() {

System.out.println("我是TEST2无修饰符修饰的方法");

}

}

public class Main {

public static void main(String[] args) {

TEST2 test2 = new TEST2();

/*以下设计代码分别调用 demo1 demo2 demo3 demo4 test1 test2 test3 test4方法和t1 t2 t3 t3 e1 e2 e3 e4属性,结合程序运行结果理解继承和权限修饰符的用法与区别*/

}

}

public class TEST1 {

private String t1 = "这是TEST1的私有属性";

public String t2 = "这是TEST1的公有属性";

protected String t3 = "这是TEST1受保护的属性";

String t4 = "这是TEST1的默认属性";

private void tese1() {

System.out.println("我是TEST1用private修饰符修饰的方法");

}

public void tese2() {

System.out.println("我是TEST1用public修饰符修饰的方法");

}

protected void tese3() {

System.out.println("我是TEST1用protected修饰符修饰的方法");

}

void tese4() {

System.out.println("我是TEST1无修饰符修饰的方法");

}

}

public class TEST2 extends TEST1{

private String e1 = "这是TEST1的私有属性";

public String e2 = "这是TEST1的公有属性";

protected String e3 = "这是TEST1受保护的属性";

String e4 = "这是TEST1的默认属性";

public void demo1() {

System.out.println("我是TEST2用public修饰符修饰的方法");

}

private void demo2() {

System.out.println("我是TEST2用private修饰符修饰的方法");

}

protected void demo3() {

System.out.println("我是TEST2用protected修饰符修饰的方法");

}

void demo4() {

System.out.println("我是TEST2无修饰符修饰的方法");

}

public class Main {

public static void main(String[] args) {

TEST2 test2 = new TEST2();

/*在下面分别调用 demo1 demo2 demo3 demo4 test1 test2 test3 test4方法

t1 t2 t3 t3 e1 e2 e3 e4属性,好好理解继承和权限修饰符的用法与区别*/

}

}

技术分享图片

 

实验2  第五章测试程序反思,继承知识总结。

测试程序1

编辑、编译、调试运行教材程序5-85-95-10(教材174-177页);

结合程序运行结果,理解程序代码,掌握Object类的定义及用法;

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)

   {

      Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);

      Employee alice2 = alice1;

      Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);

      Employee 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);

 

      Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);

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

   }

}

package equals;

 

import java.time.*;

import java.util.Objects;

 

public class Employee

{

   private String name;

   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

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

            + "]";

   }

}

package equals;

 

public class Manager extends Employee

{

   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;

      Manager other = (Manager) otherObject;

      // super.equals checked that this and other belong to the same class

      return bonus == other.bonus;

   }

 

   public int hashCode()

   {

      return java.util.Objects.hash(super.hashCode(), bonus);

   }

 

   public String toString()

   {

      return super.toString() + "[bonus=" + bonus + "]";

   }

}

 

 技术分享图片

 

 

测试程序2

编辑、编译、调试运行教材程序5-11(教材182页);

结合程序运行结果,理解程序代码,掌握ArrayList类的定义及用法;

package arrayList;

 

import java.util.*;

 

/**

 * This program demonstrates the ArrayList class.

 * @version 1.11 2012-01-26

 * @author Cay Horstmann

 */

public class ArrayListTest

{

   public static void main(String[] args)

   {

      // fill the staff array list with three Employee objects

      ArrayList<Employee> staff = new ArrayList<>();

 

      staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15));

      staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1));

      staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));

 

      // raise everyone‘s salary by 5%

      for (Employee e : staff)

         e.raiseSalary(5);

 

      // print out information about all Employee objects

      for (Employee e : staff)

         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="

               + e.getHireDay());

   }

}

 

package arrayList;

 

import java.time.*;

 

public class Employee

{

   private String name;

   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;

   }

}

 

测试程序技术分享图片

 

3

编辑、编译、调试运行程序5-12(教材189页);

结合运行结果,理解程序代码,掌握枚举类的定义及用法;

package enums;

 

import java.util.*;

 

/**

 * This program demonstrates enumerated types.

 * @version 1.0 2004-05-24

 * @author Cay Horstmann

 */

public class EnumTest

{  

   public static void main(String[] args)

   {  

      Scanner in = new Scanner(System.in);

      System.out.print("Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE) ");

      String input = in.next().toUpperCase();

      Size size = Enum.valueOf(Size.class, input);

      System.out.println("size=" + size);

      System.out.println("abbreviation=" + size.getAbbreviation());

      if (size == Size.EXTRA_LARGE)

         System.out.println("Good job--you paid attention to the _.");      

   }

}

 

enum Size

{

   SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");

 

   private Size(String abbreviation) { this.abbreviation = abbreviation; }

   public String getAbbreviation() { return abbreviation; }

 

   private String abbreviation;

}

 技术分享图片

 

 

实验3采用个人账号登

 

https://pintia.cn/完成《2018秋季西北师范大学面向对象程序设计(Java)(ch1-ch5)测试题2》,测试时间60分钟;

实验4: 课后完成实验3未完成的测试内容。

实验总结:

这次实验比前面实验话简单,Object类的常用API用法;ArrayList类用法与常用API枚举类使用方法;

 

继承中的this和super:等等

以前做实验时候自己一人完成是很困难的,都是有那么一些人的指点下完成的;自己想到自己怎么那么笨,现在想也不是笨,是我在初始学的内容还没弄懂。

通过这次实验想到其实自己一个人完成是多么美好的。

以上是关于201771010101 白玛次仁 《2018面向对象程序设计(Java)》第七周学习总结的主要内容,如果未能解决你的问题,请参考以下文章

201771010101 白玛次仁 《2018面向对象程序设计(Java)课程学习进度条》

201771010101 白玛次仁 《2018面向对象程序设计(Java)》第十七周学习总结

201771010101 白玛次仁 《2018面向对象程序设计(Java)》第九周学习总结

201771010101 白玛次仁 《2018面向对象程序设计(Java)》第七周学习总结

201771010101 白玛次仁 《2018面向对象程序设计(Java)》第十六周学习总结

201771010101 白玛次仁