201871010135 张玉晶《面向对象程序设计（java）》第七周学习总结

201871010135  张玉晶《面向对象程序设计（java）》第七周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11435127.html
作业学习目标	掌握四种访问权限修饰符的使用特点； 掌握Object类的用途及常用API； 掌握ArrayList类的定义方法及用途； 掌握枚举类定义方法及用途； 结合本章实验内容，理解继承与多态性两个面向对象程序设计特征，并体会其优点。

1、实验目的与要求

(1) 掌握四种访问权限修饰符的使用特点；

(2) 掌握Object类的用途及常用API；

(3) 掌握ArrayList类的定义方法及用法；

（4）掌握枚举类定义方法及用途；

（5）结合本章实验内容，理解继承与多态性两个面向对象程序设计特征，并体会其优点。

2、实验内容和步骤

实验1： 在“System.out.println(...);”语句处按注释要求设计代码替换...，观察代码录入中IDE提示，以验证四种权限修饰符的用法。

程序代码如下：

 class Parent {
     private String p1 = "这是Parent的私有属性";
     public String p2 = "这是Parent的公有属性";
     protected String p3 = "这是Parent受保护的属性";
     String p4 = "这是Parent的默认属性";
     private void pMethod1() {
         System.out.println("我是Parent用private修饰符修饰的方法");
     }
     public void pMethod2() {
         System.out.println("我是Parent用public修饰符修饰的方法");
     }
     protected void pMethod3() {
         System.out.println("我是Parent用protected修饰符修饰的方法");
     }
     void pMethod4() {
         System.out.println("我是Parent无修饰符修饰的方法");
     }
 }
 class Son extends Parent{
     private String s1 = "这是Son的私有属性";
     public String s2 = "这是Son的公有属性";
     protected String s3 = "这是Son受保护的属性";
     String s4 = "这是Son的默认属性";
     public void sMethod1() {
         System.out.println(a);//分别尝试显示Parent类的p1、p2、p3、p4值
         System.out.println("我是Son用public修饰符修饰的方法");
     }
     private void sMethod2() {
         System.out.println("我是Son用private修饰符修饰的方法");
     }
     protected void sMethod() {
         System.out.println("我是Son用protected修饰符修饰的方法");
     }
     void sMethod4() {
         System.out.println("我是Son无修饰符修饰的方法");
     }
 }
 public class Demo {
     public static void main(String[] args) {
         Parent parent=new Parent();
         Son son=new Son();
         System.out.println(b);    //分别尝试用parent调用Paren类的方法、用son调用Son类的方法
     }
 }

对代码中的 a ， b 处做如下填空：

1.

2.

3.

4.

由以上可知，不管方法或属性，只要是private修饰的 ，都只能在本类中用； 子类继承父类的方法与属性。

将子类，父类，主类分开，各建一个类   ：

1.子类中调用父类的方法和属性：

2.  主类中调用Parent类的属性和方法

3. 主类中调用Son类的属性和方法

由以上可知： 用public修饰的属性和方法是公用的，用friendly和protected修饰的属性和方法，只有在同一个包中时能访问，特别：protected修饰的，在有继承关系时，可在不同的包中访问。

四种权限修饰符的访问范围：

访问范围	private	friendly（默认）	protected	public
同一个类	可以访问	可以访问	可以访问	可以访问
同一个包内的类	不可以访问	可以访问	可以访问	可以访问
不同包内的类	不可以访问	不可以访问	可以访问	可以访问
不同包并且不是子类	不可以访问	不可以访问	不可以访问	可以访问

实验2：导入第5章以下示例程序，测试并进行代码注释。

测试程序1：

EqualsTest.java    :

 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", , , , );
       Employee alice2 = alice1;
       Employee alice3 = new Employee("Alice Adams", , , , );
       Employee bob = new Employee("Bob Brandson", , , , );

       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", , , , );
       Manager boss = new Manager("Carl Cracker", , , , );
       boss.setBonus();
       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());
    }
 }

运行结果如下：

Employee.java

 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 / ;
       salary += raise;
    }

    public boolean equals(Object otherObject)
    {
       // 快速测试，看看这些对象是否相同
       if (this == otherObject) return true;

       // 如果显示参数为空，则必须返回false
       if (otherObject == null) return false;

       // 如果类不匹配，它们就不相等
       if (getClass() != otherObject.getClass()) return false;

       // 现在我们知道 otherObject 是一个非空雇员
       Employee other = (Employee) otherObject;

       // 测试字段是否具有相同的值
       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 + "]";
    }
 }

运行结果如下：

Manager.java

 package equals;

 public class Manager extends Employee//子类Manager继承父类Employee
 {
    private double bonus;

    public Manager(String name, double salary, int year, int month, int day)
    {
       super(name, salary, year, month, day); //利用super调用父类构造器
       bonus = ;
    }

    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：

ArrayListTest.java

 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)
    {
       // 用三个Employee 对象填充数组列表
       ArrayList<Employee> staff = new ArrayList<Employee>();

       staff.add(new Employee("Carl Cracker", , , , ));
       staff.add(new Employee("Harry Hacker", , , , ));
       staff.add(new Employee("Tony Tester", , , , ));

       // 把每个人的薪水提高%5
       for (Employee e : staff)
          e.raiseSalary();

       // 打印出关于Employee 类的所有信息
       for (Employee e : staff)
          System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
             + e.getHireDay());
    }
 }

运行结果如下：

测试程序3：

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

运行结果如下：

测试程序4：录入以下代码，结合程序运行结果了解方法的可变参数用法

public class TestVarArgus {

public static void dealArray(int... intArray){

for (int i : intArray)

System.out.print(i +" ");

System.out.println();

}

public static void main(String args[]){

dealArray();

dealArray(1);

dealArray(1, 2, 3);

}

}

1.   代码如下：

 public class TestVarArgus {
         public static void dealArray(int... intArray)//运用泛型数组列表，传参数，(int... intArray)表示参数的个数是可变的，但都为整型
         {
             for (int i : intArray)
                 System.out.print(i +" ");  

             System.out.println();
         }
         public static void main(String args[]){
             dealArray();
             dealArray();
             dealArray(, , );
         }
     }

运行结果如下：

2. 代码如下：

     public class TestVarArgus {
         public static void dealArray(String... stringArray)//运用泛型数组列表，传参数，参数为字符串型
         {
             for (String i : stringArray)
                 System.out.print(i +" ");  

             System.out.println();
         }
         public static void main(String args[]){
             dealArray("friend");
             dealArray("zhang qi" );
             dealArray("wang xue","qi xue");
         }
     }

运行结果如下：

实验:3：编程练习：参照输出样例补全程序，使程序输出结果与输出样例一致。

程序运行结果如下：

Parent's Constructor with a boolean parameter

Son's Constructor without parameter

Son's method()

Parent's method()

代码如下：

 package zyj;

 public class Demo {
     public static void main(String[] args) {
         Son son = new Son();
         son.method();
     }
 }
 class Parent {
     Parent() {
         System.out.println("Parent's Constructor without parameter");
     }
     Parent(boolean b) {
         System.out.println("Parent's Constructor with a boolean parameter");
     }
     public void method() {
         System.out.println("Parent's method()");
     }
 }
 class Son extends Parent {
 //补全本类定义
     Son(){
         super(false);
         System.out.println("Son's Constructor without parameter");
     }
     public void method() {
         System.out.println("Son's method()");
         super.method();
     }
 }

运行结果如下：

实验总结：在本次实验中，验证了四种权限修饰符的范围，private只能在自身的类中访问，protected在同一包不同类中能访问，但是在不同包中不能访问，（有继承关系但在不同的包中的两个类可以访问），  public是在不同的包和不同的类都可以访问，默认修饰符（friendly)在同一包不同类中可以访问，不同包中不能访问。以及泛型数组列表的学习，其中传的参数是可变的，注意的是参数的类型； 还有枚举类的学习。