作业day02

一程序题

1．（1）编写一个圆类Circle，该类拥有： 

①一个成员变量 

Radius（私有，浮点型）；  // 存放圆的半径； 

 ②两个构造方法 

          Circle( )                 // 将半径设为0 

          Circle(double  r )         //创建Circle对象时将半径初始化为r        ③ 三个成员方法 

            double getArea( )       //获取圆的面积             double getPerimeter( )   //获取圆的周长 

            void  show( )          //将圆的半径、周长、面积输出到屏幕 

（2）编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有： 

①一个成员变量 

double hight（私有，浮点型）；  // 圆柱体的高； 

 ②构造方法 

          Cylinder (double r, double  h )           //创建Circle对象时将半径初始化为r 

  ③ 成员方法 

            double getVolume( )             //获取圆柱体的体积 

            void  showVolume( )             //将圆柱体的体积输出到屏幕 

编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。

 

public class Circle {

    private static final double MathPI = 3.14;

    private double radius;    //圆半径

    Circle(){                 //构造方法

       radius = 0.0;    

    }

    Circle(double r){         //构造方法

       radius = r;

    }

    double getPerimeter(){   //求圆周长

       return 2*MathPI*radius;

    }

    double getArea(){        //求圆面积

       return MathPI*radius*radius;

    }

    void disp(){             //显示

       System.out.println("圆半径="+radius);

       System.out.println("圆周长="+getPerimeter());

       System.out.println("圆面积="+getArea());

    }

}

 

public class Cylinder extends Circle {

    private double hight;           //圆柱高

    Cylinder(double r, double h){   //构造方法

       super(r);

       hight = h;

    }

    public double getVol(){         //求圆柱体积

       return getArea()*hight;

    }

    public void dispVol(){         //显示圆柱体积

       System.out.println("圆柱体积="+getVol());

    }

}

 

public class TestCylinder {

 

    public static void main(String[] args) {

       // TODO自动生成的方法存根

       Circle ci = new Circle(10.0);

       ci.disp();

       Cylinder cy = new Cylinder(5.0,10.0);

       cy.disp();

       cy.dispVol();

    }

}

 

2.定义一个表示学生信息的类Student，要求如下：  

（1）类Student的成员变量： 

sNO 表示学号；sName表示姓名；sSex表示性别；sAge表示年龄；sJava：表示Java课程成绩。 

（2）类Student带参数的构造方法：  

在构造方法中通过形参完成对成员变量的赋值操作。 

（3）类Student的方法成员： getNo（）：获得学号；  getName（）：获得姓名；  getSex（）：获得性别； getAge（）获得年龄； 

getJava（）：获得Java 课程成绩 

（4）根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。 

 

public class Student {

 

    private String sNO, sName, sSex;

    private int sAge, sJava;

    public Student(String XH, String XM, String XB, int NL, int XF){

       super();

       sNO = XH;

       sName = XM;

       sSex = XB;

       sAge = NL;

       sJava =XF;

    }

    public String getNO(){

       return sNO;

    }

    public String getName(){

       return sName;

    }

    public String getSex(){

       return sSex;

    }

    public int getAge(){

       return sAge;

    }

    public int getJava(){

       return sJava;

    }

   

    public static void main(String[] args) {

       // TODO自动生成的方法存根

       Student[] st = new Student[5];

       st[0] = new Student("09zc01","张三","男",19,94);

       st[1] = new Student("09zc02","李四","男",20,85);

       st[2] = new Student("09zc03","王五","女",18,96);

       st[3] = new Student("09zc04","赵六","男",17,90);

       st[4] = new Student("09zc05","杨七","女",21,88);

       int max = 0, min = 100, sum = 0;

       System.out.println("学生信息：");

       for(int i = 0; i < st.length; i ++){

           if(st[i].sJava < min)

              min = st[i].sJava;

           if(st[i].sJava > max)

              max = st[i].sJava;

           sum = sum + st[i].sJava;

           System.out.println("学生编号："+st[i].getNO()+"，姓名："+st[i].getName()+"，性别："+st[i].getSex()+"，年龄："+st[i].getAge()+"，Java学分："+st[i].getJava());

       }

       System.out.println("共有学生："+st.length+"，平均成绩："+sum/st.length);

       System.out.println("最小学分："+min+"，最大学分："+max);

    }

}

 

3.有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

 

public class deme03 {

 

    public static void main(String[] args) {

       // TODO自动生成的方法存根

       int[] a = new int[]{2, 5, 6, 18, 25, 37, 37,55};

       int[] b = new int[a.length+1];

       int t1 = 0, t2 = 0;

       int i = 0;    

       Scanner s= new Scanner(System.in);

       System.out.print("请输入一个整数：");

       int num = s.nextInt();

       if(num >= a[a.length-1]) {

           b[b.length-1] = num;

           for(i=0; i<a.length; i++) {

              b[i] = a[i];

              }

       } else {

           for(i=0; i<a.length; i++) {

              if(num >= a[i]) {

                  b[i] = a[i];

              } else {

                  b[i] = num;

                  break;

              }

           }

           for(int j=i; j<a.length; j++) {     

              b[j+1] = a[j];    

           }

       }    

       for (i = 0; i < b.length; i++) {    

           System.out.print(b[i] + " ");   

       }

    }

}

 

二概念以及知识点

1.     Strings = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。

通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。

2.    是否可以继承String类?

String类是final类故不可以继承。

3.     Strings = new String("xyz");创建了几个String Object?二者之间有什么区别？

两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

4.     数组有没有length()这个方法? String有没有length()这个方法？

数组没有length()这个方法，有length的属性。String有有length()这个方法。

5.     请说出作用域public，private，protected，以及不写时的区别

这四个作用域的可见范围如下表所示。

 

说明：如果在修饰的元素上面没有写任何访问修饰符，则表示friendly。

 

作用域	当前类	同一package	子孙类	其他package
public	√	√	√	√
protected	√	√	√	×
friendly	√	√	×	×
private	√	×	×	×

 

备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。

6.     面向对象的编程语言有哪4个主要的特征。

封装、继承、抽象、多态性。

7.     两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?（探究一下对象的equal方法和hashcode方法）

equal方法

Object类的equals方法用于检测一个对象是否等于另外一个对象，而Object类中这个方法的定义为两个对象是否具有相同的引用。源码如下：

Java代码

 

   1.      

   2. public boolean equals(Object obj) { 

   3.    return (this == obj); 

   4.    } 

 

   

public booleanequals(Object obj) {

return (this ==obj);

    }

 

看起来没有什么问题，两个对象具有相同的引用，那这两个对象一定是相等的，但在实际应用中，这样的比较其实并没有什么实际意义，经常发生的场景就是需要比较两个对象的状态的相等性，比如某个对象的唯一性标识一致我们就认为这两个对象相等。java规范中对equal方法有如下要求

自反性：对于任何非空引用x,x,equal(x)应该返回true

对称性：对于任何引用x，x如果x.equal(y)返回true，那么y.equal(x)也应该返回true

传递性：对于任何x，y，z，如果x.equal(y)返回true，y.equal(z)返回true，那么z.equal(x)返回true也应该返回true。

一致性：如果x，y的引用没有发生变化，那么反复调用equal方法应该返回同样的结果

非空性：对于任意非空引用x，x.equal(null)都应该返回false

为了满足实际需要，这个时候我们就需要重写equal方法，针对规范，比较典型的写法如下：

Java代码

 

   1. /**

   2.     * [简要描述]:<br/>

   3.     * [详细描述]:<br/>

   4.      * 

   5.     * @author GraMind

   6.     * @param obj

   7.     * @return

   8.     * @exception 

   9.     * @see java.lang.Object#equals(java.lang.Object)

  10.     */ 

  11.    @Override 

  12.    public boolean equals(Object obj) 

  13.    { 

  14.        if (this == obj)                                         1 

  15.             return true; 

  16.        if (obj == null)                                         2 

  17.             return false; 

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

  19.             return false; 

  20.        ClassName other = (ClassName) obj;                       4 

  21.        if (id != other.id)                                      5 

  22.             return false; 

  23.        ....... 

  24.        return true; 

  25.    } 

 

/**

     * [简要描述]:<br/>

     * [详细描述]:<br/>

     *

     * @author GraMind

     * @param obj

     * @return

     * @exception

     * @see java.lang.Object#equals(java.lang.Object)

     */

    @Override

    public boolean equals(Object obj)

    {

        if (this == obj)                                         1

            return true;

        if (obj == null)                                         2

            return false;

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

            return false;

        ClassName other = (ClassName) obj;                       4

        if (id != other.id)                                      5

            return false;

        .......

        return true;

    }

 

 

对于上面的代码

1）检测两者是否引用同一个对象

2）检测object是否为null，如果为null直接返回false

3）避免父子类引用相同的域（比如上类父子都具有id属性），比较是否属于同一级类，如果每个子类都具有统一的语义也可以使用instanceof来检测

4)转换要比较的类为对应的类类型变量

5)根据需要比较相应的域

注意：如果在子类中重写了equal方法，就要在其中包含super.equal(...)。

散列码

散列码是有对象导出来的一个整形值，且没有规律。如果重写equal方法那么就必须重写hashCode方法

想要明白为什么这样做，你必须要先知道Java中的集合。　　

总的来说，Java中的集合（Collection）有两类，一类是List，再有一类是Set。

你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。

那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？

这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。

也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。  

于是，Java采用了哈希表的原理。哈希（Hash）实际上是个人名，由于他提出一哈希算法的概念，所以就以他的名字命名了。

哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。

初学者可以这样理解，hashCode方法实际上返回的就是对象存储的物理地址（实际可能并不是，比如大家可以看下String的hashCode实现）。 

这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。

如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，

就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。

所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。 

所以，Java对于eqauls方法和hashCode方法是这样规定的：

1、如果两个对象相同，那么它们的hashCode值一定要相同；2、如果两个对象的hashCode相同，它们并不一定相同     上面说的对象相同指的是用eqauls方法比较。

8.     能不能自己写个类，也叫java.lang.String？

可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，原来所有用了java.lang.String类的都将出现问题。

虽然java提供了endorsed技术，可以覆盖jdk中的某些类，具体做法是….。但是，能够被覆盖的类是有限制范围，反正不包括java.lang这样的包中的类。

9.     一个".java"源文件中是否可以包括多个类(不是内部类)?有什么限制?

一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

 

一个.java源文件可以有多个类，但最多只能有一个public类。

 

java程序是从一个public类的main函数开始执行的，（其实是main线程）。    只能有一个public类是为了给类装载器提供方便。     一个public   类只能定义在以它的类名为文件名的文件中。

 

 

每个编译单元（文件）都只有一个public   类。因为每个编译单元都只能有一个公共接口，用public类来表现。该接口可以按照要求包含众多的支持包访问权限的类。如果有一个以上的public   类，编译器就会报错。  并且public类的名称必须与文件名相同（严格区分大小写）。  当然一个编译单元内也可以没有public类。

10. 是否可以继承String类型？

String类是final类故不可以继承。