201771010128王玉兰《面象对象程序设计（Java）》第七周学习总结

Posted 2021-01-12 wang963

第一部分：基础知识总结:

1继承

A:用已有类来构建新类的一种机制，当定义了一个新类继承一个类时，这个新类就继承了这个类的方法和域以适应新的情况；

B：特点：具有层次结构、子类继承父类的方法和域；

C:优点：代码可重用、父类的域和方法可用于子类、设计应用程序变得更加简单、可以轻松定义子类。

2类、超类和子类

A:Super关键字有两个用途，一是调用超类的方法（super.方法名（）），二是调用超类的构造

（super.()）;  继承层次：从一个超类扩展而来的类集合；继承链：在继承层次中，从某个类个类到其祖先的路径； Java不支持多继承。

B:多态性：泛指在程序中同一个符号在不同的情况下具有不同解释的现象；

阻止继承：final类和方法：不允许继承的类成为Final类，在类的定义中用修饰符加以说明；

类中的方法可定义子类，这时不能覆盖方法； String类是final类的一个例子。

C；抽象类：包含一个或多个抽象方法的类本身必须被声明为抽象类； 抽象方法充当着占位的角色，他们的具体实现在子类中 ； 抽象不能被实例化，即不能创建对象，只能产生子类。

D:访问修饰符：private：只有该类可以访问，public：该类或非该类均可访问，protected:该类及其子类可以访问，同一个包中的类也可以访问。(注：不写访问修饰符时默认为friendly)

1)仅对本类可见——private

2)对所有类可见——public

3)对本包和所有子类可见——protected

4)对本包可见——默认（friendly），不需要修饰符

A:使用修饰符的原因：实现受限信息隐藏

B：信息隐藏的目的：

-对类中任何实现细节的更改不会影响使用该类的代码

-防止用户意外删除数据

-易于使用类

3.Object：所有类的超类

A：Object是Java中所有类的祖先；

B：可以使用类型为Object的变量指向任意类型的对象；

C：Object类中的equals方法用于测试某个对象是否另一个对象也相等；

D：定义类中的equals方法时，可调用超类的equals方法（super.equals）

E：如果需要检测连个对象状态的相等性，就需要在新类定义中需要覆盖equals方法；

F:Object类中的HashCode方法导出某个对象的散列码，两个相等对象的散列码相等；

G：Object类中的toString方法返回一个代表该对象域值的字符串；

H：定义子类的toString方法时，可先调用超类的toString方法，super.toString()。

1)equals方法：用于检测一个对象是否等于另一个对象。

2）hashCode方法：导出某个对象的散列码。散列码是任意整数，表示对象的存储地址。两个相等对象的散列码相等。

3）toString方法：返回一个代表该对象值域的字符串。

4.泛型数组列表

A：Arraylist<T>=new Arraylist<T>

B:Arrarylist的构造器：a:添加新元素，b:统计个数，c:调整大小，d:访问，e:增加与删除。

5.对象包装器与自动打包

A:包装器：所有基本数据类型都有着对应的预定义类；

B：对象包装器类不可变的，它还是final类，因此不能定义它们的子类；

C:打包和拆包是编译器认可的。

6.参数数量可变的方法

A:定义：可用可变的参数数量调用的方法

B：用户可以自己定义可变参数的方法，并将参数指定为任意类型，甚至是基本类型。

7枚举类

A:声明枚举类  public enum Grade{A,B,C,D,E}；

B:它包括一个关键字enum,一个新枚举类型的名字Grade以及Grade定义的一组值，这里的值即非整型，又非字符型。

8.继承设计的技巧

A:将公共操作和域放在超类；

B：不要使用受保护的域；

C:使用继承实现“is-a”关系；

D：除非所有继承的方法都有意义，否则就不要使用继承；

E:在覆盖方法时，不要改变预期的行为；

F:使用多态，而非类型信息；

G：不要过多地使用反射。

注：面向对象程序有三大特点：

1）    继承

2）多态：方法的覆盖（方法的重写overriding）、方法的重载（overloading）

3）封装一：继承 继承就是子类对父类的继承。包含父类的方法，还可以添加自己独有的方法。二：多态 方法名称允许相同，但根据传入参数的类型，个数不同形成多态的形式，方法覆盖满足5个条件（方法覆盖：存在继承关系）

A：方法名称一致：B:参数一致；C：返回值一致；D:方法的权限不能比父类的小；E：不能比父类抛出更多的异常。

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("我是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 = "这是TEST2的私有属性";    public String e2 = "这是TEST2的公有属性";    protected String e3 = "这是TEST2受保护的属性";    String e4 = "这是TEST2的默认属性";    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属性，结合程序运行结果理解继承和权限修饰符的用法与区别*/    } }

public class TEST1 {
	
	   private String t1 = "这是TEST1的私有属性";
		public String t2 = "这是TEST1的公有属性";
		protected String t3 = "这是TEST1受保护的属性";
		String t4 = "这是TEST1的默认属性";
		private void test1() {
			System.out.println("我是TEST1用private修饰符修饰的方法");
		}
		public void test2() {
			System.out.println("我是TEST1用public修饰符修饰的方法");
		}
		protected void test3() {
			System.out.println("我是TEST1用protected修饰符修饰的方法");
		}
		void test4() {
			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("我是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属性，结合程序运行结果理解继承和权限修饰符的用法与区别*/
	
			 test2.demo1();
		        test2.demo3();
		        test2.demo4();
		        test2.test2();
		        test2.test3();
		        test2.test4();
		        System.out.println(test2.t2);
		        System.out.println(test2.t3);
		        System.out.println(test2.t4);
		        System.out.println(test2.e2);
		        System.out.println(test2.e3);
		        System.out.println(test2.e4);
		    }
		
		}

　　

运行结果：

 

 

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

测试程序1：

?   编辑、编译、调试运行教材程序5-8、5-9、5-10（教材174页-177页）；

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

/**
 * 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());
   }
}
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)
   {
      // 快速检查对象是否相同，则返回flase
      if (this == otherObject) return true;

      // 如果显示参数为空
      if (otherObject == null) return false;

      // getClass()方法是对象的类，这里就是如果两个对象的类不一样，那么就不相等
      if (getClass() != otherObject.getClass()) return false;

      // 现在我们知道另一个对象是非空雇员
      var 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
            + "]";
   }
}

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;
      var other = (Manager) otherObject;
      //检查这个和其他属于同一个类
      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类的定义及用法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)
   {
      // 用三个雇员对象填充工作人员数组列表
      var staff = new ArrayList<Employee>();

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

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

      //打印所有员工对象的信息
      for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
               + e.getHireDay());
   }
}

　　

测试程序3：

?   编辑、编译、调试运行程序5-12（教材189页）；

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

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)//程序入口
   {  
      var in = new Scanner(System.in);//构造一个Scanner类
      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中equals方法、hashCode方法、toString方法的用法，面向对象程序设计是由继承、多态、封装组成；通过实验一的验证中再一次理解了子类继承父以及受保护访问权限的具体使用过程；在老师和学长的指导和帮助下，收获一点，但是，在自己面对编程题时有很多不足，在接下来的学习过程中追究进步，独立思考。