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

项目

内容

这个作业属于哪个课程

https://www.cnblogs.com/nwnu-daizh/

这个作业的要求在哪里

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

作业学习目标
  1. 掌握四种访问权限修饰符的使用特点；
  2. 掌握Object类的用途及常用API；
  3. 掌握ArrayList类的定义方法及用途；
  4. 掌握枚举类定义方法及用途；
  5. 结合本章实验内容，理解继承与多态性两个面向对象程序设计特征，并体会其优点。

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)在同一包不同类中可以访问，不同包中不能访问。以及泛型数组列表的学习，其中传的参数是可变的，注意的是参数的类型； 还有枚举类的学习。

最新文章

  1. SQL Server-聚焦NOT IN VS NOT EXISTS VS LEFT JOIN...IS NULL性能分析（十八）
  2. Verilog学习笔记简单功能实现（二）...............全加器
  3. php开发客服系统(持久连接+轮询+反向ajax 转载 http://www.tuicool.com/articles/2mU7v2R)
  4. 建模算法（十）&mdash;&mdash;灰色理论之关联度分析
  5. thinkPHP 中去除URL中的index.php
  6. framMaker、Velocity模版引擎
  7. IOS 日期选择
  8. MyEclipse 2013 新功能介绍
  9. D3.js：力导向图
  10. 函数响应式编程及ReactiveObjC学习笔记 (二)
  11. javascript一些比较难理解的知识点
  12. [转]python单元测试unittest
  13. xpadder教程：自定义设置游戏手柄的图片
  14. New UWP Community Toolkit - ImageEx
  15. MyBatis基础：MyBatis入门（1）
  16. 安装JDK并配置环境变量以及Hello World
  17. [poj P2976] Dropping tests
  18. Mingw下载
  19. JQuery 简单表格验证
  20. Btree并发内存回收

热门文章

  1. JetBrains IntelliJ IDEA 2019 for Mac(Java集成开发环境) 2019.3.1
  2. Educational Codeforces Round 71 (Rated for Div. 2)
  3. Fiddler修改请求数据
  4. 详解 Redis 应用场景及原理
  5. DirectShow 获取音视频输入设备列表
  6. Filter 原理
  7. js函数只执行一次，函数重写，变量控制与闭包三种做法
  8. Java并发编程入门，看这一篇就够了
  9. mysql多表关联update
  10. 面试官常问的Nginx的那几个问题？