Java学习笔记八

31.

import语句不仅可以导入类，还增加了导入静态方法和静态域的功能，当使用这些方法时就可以不用加前缀，当然，这样可能不利于程序的清晰度，但是对于笨重的静态方法来说是值得用的，比如说

Math类中的方法

package com.jianjian;

 

import static java.lang.Math.*;

 

public class MathTest

{

   public static void main(String[] args)

   {

      double a =pow(4,2);

      System.out.println(a);

     

     

   }

}

 

32.

包 packager的作用是将生成的类放入包中，

33．

在D:\myclass下面会生成一个Welcome.class的文件，接着：

 

开始→运行→CMD 确定（打开DOS窗口）

把路径换回D:\myclass

（操作如：C:\Documents and Settings\Administrator>E: 回车

E:\cd myclass 回车）

现在输入：java Welcome 哈哈，看到什么了！！！

 

 

常用的更换路径的命令： “cd” “cd..”

比如现在有这样一条路径：E:\文件夹A\文件夹B\文件夹C

若您现在的位置是C:\Documents and Settings\Administrator>

输入E: 回车

路径换为 E:\

输入“cd 文件夹A”（不要加双引号）

路径变为 E:\文件夹A

再输入“cd 文件夹B”

路径变为 E:\文件夹A\文件夹B （依此类推）

此时再输入“cd..”看看，

又变回了 E:\文件夹A

 

所以：cd.. 是退回上级目录

 

 

33.

（关于谷歌输入法的顿号修改：属性设置——>词典——>编辑自定义短语——>添加——>“缩写”填“/”，自定义短语填“、”——>一路确定）

 

包作用域：

前面已经接触过访问修饰符：public 、 private.标记为public的部分可以被任意的类使用，标记为private的部分只能被定义它们的类使用。如果没有指定public、private则可以被同一个包下的所有方法访问

 

 

 

34.

一般情况下，我们喜欢利用构造方法为非共有类赋初值，被副处职的属性叫做域，其实我们常常习惯将域定义为私有，在继承中，当子类想调用父类中的私有域时，不能直接调用，只能通过公有的接口才能实现，接口其实说的就是父类中返回私有域的方法：

35.

在继承中，子类可以使用父类中的所有域，而不用重新定义这些域，

例如private double salary;存在父类中的花子类就不需要重新定义，如果想加入新的域就要在子类中定义了。

 

 

36.很多的时候，继承的使用频率是很高的，因为我们总是会遇到像这种情况：要处理的对象，大多数是统一的，但是有那么一两个是特别的需要额外的改进他们，如果数据是庞大的，继承利用数组实现数据的输出就更显得重要！而且由于子类不能访问父类中的私有域，所以输出时建议用方法返回私有域，最后的输出也应该通过方法返回。

看下面的程序。统计员工 staff 的工资，他分为employee和manager，其中manager的工资加上奖金bouns。

/*

 * 继承中还有很多我不知道的东西

 */

package com.jianjian2;

 

public class StaffTest

{

   public static void main(String[] args)

   {

      Boss boss = new Boss("laoban",5000.0,398.5);//第三个数据是奖金；

      Employee[] staff = new Employee[3];//定义三个数据的数组

      staff[0] = boss;//向下类型转换

      staff[1] = new Employee("zhangSan",4534.3);

      staff[2] = new Employee("liSi",3422.2);

      for(Employee e : staff)

      {

        System.out.println(e.getName());

        System.out.println(e.getSalary());

       

      }

     

   }

}

class Employee

{

   private Stringname;

   private double salary;

   public Employee(String name,double salary)

   {

      this.name = name;

      this.salary = salary;

     

   }

  

   public String getName()

   {

      return name;

   }

   public double getSalary()

   {

      return salary;

   }

}

class Boss extends Employee

{

   public Boss(String name ,double salary,double bouns)

   {

      super(name,salary);//这里是个难点，子类调用父类的构造方法，其实就是要把子类的数据完善，即也让子类具有父类的域；

      this.bouns = bouns;

     

   }

   private double bouns;

   public double getSalary()

   {

     

      return bouns + super.getSalary();

   }

}

 

37.

不允许被继承的类称为final类

 

38.

Java里有很多难以理解并且容易忽略的约定，比如说抽象类 abstract ；抽象类不能被实例化，含有抽象方法的类一定是抽象类，抽象类可以有具体的方法，那么什么是抽象方法，抽象方法又有什么意义呢？其实抽象类既然不能被实例化，就只能被子类所继承了，抽象方法在父类中声明，在子类中实现，一个难以理解的约定：

如果子类只定义（实现）了父类部分抽象方法，或没有定义抽象方法，则子类也必须定义为抽象类，（为了防止子类被实例化），如果子类实现了父类中的全部抽象方法（可不是全部方法），子类就不是抽象的了；

 

39.

至于说抽象方法的意义：我们只是在父类中声明一下大概，但是我们并不知道接下来子类要怎么实现这个方法，比如说，我们在子类中定义一个返回对员工评价的方法

Abstract public String evaluate();

然后在子类中重写这个方法，

public String evaluate()

{

}

有一点必须记住的是上面的约定，加入父类只有真么一个抽象方法，子类又实现了他，子类就不是抽象类了；

那么为什么定义抽象方法呢，如果在子类中直接定义评价方法不就行了吗？为什么要什么声明呢？

定义抽象方法有两个好处：

1. 增加程序的结构可读性；

2. 很常见的，我们可能要同意调出子类父类中的某一属性（域）；

而我们都知道域大多数是私有的，或者统一调用某一方法，比如用

for（…..)

那么我们打印的时候肯定要用父类来打，如果父类不存在该方法，或者属性，子类是无法打印出的，肯定出错，所以抽象方法起着占位的作用。比如说我们都在子类中定义了一个evaluate的方法，当想把子类父类中的全部方法打印出来的时候，父类一定要有这个方法才能打印！

 

40.

/*

 * 编写一个程序实现：定义三个员工，分别包含姓名，工资，其中有一名是经理，要求经理的工资要加上奖金；

 * 另外要实现经理的一句评价

不要陷入一个误区，父类不能实例化，如果只像上面一道题中生成父类对象将数据带入构造方法中显然是不行的，也就是说我们也就只能通过子类一个一个来写了。这里只写Manager;

 */

package com.jianjian5;

 

public class AbstractTest

{

   public static void main(String[] args)

   {

      Employee[] staff = new Employee[3];

      Manager boss = new Manager("wangwu", 3838.2, 334);

      System.out.println(boss.getEvaluate());

      System.out.println(boss.getName());

     

   }

}

abstract class Employee

{

   private Stringname;

   private double salary;

   public Employee(String name,double salary)

   {

      this.name = name;

      this.salary = salary;

     

   }

   public double getSalary()

   {

      return salary;

     

          

   }

   public String getName()

   {

      return name;

   }

   abstract public String getEvaluate();

  

}

class Managerextends Employee

{

   private double bonus;

   public Manager(String name ,double salary ,double bonus)

   {

      super(name,salary);

      this.bonus = bonus;

   }

   public double getSalary()

   {

      return super.getSalary() + bonus;

   }

   public String getEvaluate()

   {

      return "He isreally a good boss";

   }

  

}

 

 

41.

可以使用object类型的变量引用任何类型的对象；

想想会多有用，忽略类型；

 

42.

从Jdk5.0之后Java中的集合就采用泛型的方式执行了，自5.0往集合中添加基本数据类型和输出基本数据类型，都有自动打包，和拆封的功能，也就是不需要进行包装类了：

比如 list.add(3);

 

43.

集合中运用泛型之后，就确定了集合中要加入对象的类型；

比如说 List<String> list = new ArrayList<String>();

这样的话就这能向list中添加字符串类型的数据了；

可是这样做只能添加固定类型，而不能添加其他类型，图什么呢，其实就是图个方便，在输出的时候我们不用再进行强制类型转换了，

以前再没有使用泛型的时候都是默认Object类型的.

通常我们一个集合也就存放相同的对象，所以这个缺点是可以容忍的。

 

 

44.几乎所有集合都是有泛型要求的，所以对于遍历集合泛型的类

Interator 也接受泛型 ，看下面的程序：

 

package com.jianjian;

 

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

 

public class GenericTest

{

   public static void main(String[] args)

   {

      ArrayList <String> list = new ArrayList<String>();

      String[] a = new String[3];

      list.add("a");

      list.add("b");

      list.add("c");

      list.toArray(a);//这里是转换数组

      System.out.println(Arrays.toString(a));

      for(Iterator<String> ite =list.iterator();ite.hasNext();)

      {

        String s = ite.next();

        System.out.println(s);

      }

}

   }

  

 

由于没有了强制类型转换，整个代码显得整洁多了。

刚接触泛型，就多举几个例子，再复习一下知识，当想把自定义的类中的数据加到集合中时，我们要判断要加入的数据是不是已经存在了，所以要调用 equals 和hashcode方法，注意要仔细研读西面的程序，设置get 和 set 方法的原因就是提供一个公共的接口，要知道私有域只能通过共有方法来调取的：

package com.jianjian2;

 

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

 

public class GenericSetTest

{

   public static void main(String[] args)

   {

      Set<Staff> set = new HashSet<Staff>();

      set.add(new Staff("zhangsan", 23,"BeiJing"));

      set.add(new Staff("lisi",21,"TianJing"));

      set.add(new Staff("wangwu",24,"XiBanYa"));

      for(Iterator<Staff> ite = set.iterator();ite.hasNext();)

      {

        Staff staff = ite.next();

        String s1 = staff.getName();

        int s2 = staff.getAge();

        String s3 = staff.getAddress();

        System.out.println("name:" + s1 +", age:"+s2+", address: "+s3);

      }

     

     

   }

}

class Staff

{

   private Stringname;

   private int age;

   private Stringaddress;

   public Staff(String name,int age, String address)

   {

      this.name = name;

      this.age = age;

      this.address = address;

     

   }

   public String getName()

   {

      return name;

   }

   public void setName(String name)

   {

      this.name = name;

   }

   public int getAge()

   {

      return age;

   }

   public void setAge(int age)

   {

      this.age = age;

   }

   @Override

   public int hashCode()

   {

      final int prime = 31;

      int result = 1;

      result = prime * result + ((address ==null) ? 0 :address.hashCode());

      result = prime * result + age;

      result = prime * result + ((name ==null) ? 0 :name.hashCode());

      return result;

   }

   @Override

   public boolean equals(Object obj)

   {

      if (this == obj)

        return true;

      if (obj ==null)

        return false;

      if (getClass() != obj.getClass())

        return false;

      Staff other = (Staff) obj;

      if (address ==null)

      {

        if (other.address !=null)

           return false;

      }

      else if (!address.equals(other.address))

        return false;

      if (age != other.age)

        return false;

      if (name ==null)

      {

        if (other.name !=null)

           return false;

      }

      else if (!name.equals(other.name))

        return false;

      return true;

   }

   public String getAddress()

   {

      return address;

   }

   public void setAddress(String address)

   {

      this.address = address;

   }

  

}