java选做3

有部分图片和代码是直接cv的，图片上传不了，懒得搞了，代码cv到编译器应该很容易的。

(1).编写一个深圳大学类SZU和一个学院类College。SZU类中包含有多个College类的实例。调用SZU类的实例中的getColledgeNames()方法时，能够输出所有学院的名字；调用SZU类的实例中的getColledgeNumber()方法时，能够输出学院的数量。在报告中附上程序截图、运行结果截图和详细的文字说明。

class College{
   private String name;//定义学院名称
    College(String name){//有参构造为name赋值
        this.name=name;
    }
     public String getname(){
        return name;
    }
}
class SZU{
    static String []collegeName={"高等研究院","金融科技学院","材料学院","传播学院","电子与信息工程学院","法学院",
            "管理学院","化学与环境工程学院","计算机与软件学院","建筑与城市规划学院","教育学部","经济学院","人文学院","生命与海洋科学院",
            "数学与统计学院","体育学院","土木与交通学院","外国语学院","物理与光电学院","心理学院","医学部","艺术学部","政府管理学院"
    };//设置静态数组存储学院的名称;
    College[] college;
    SZU(){//无参构造
        college=new College[collegeName.length];
        for(int i=0;i<collegeName.length;i++)
            college[i]=new College(collegeName[i]);
    }
    public void getColledgeNumber(){
        System.out.println("深圳大学一共有"+college.length+"个学院");
    }
    public void getColledgeNames(){
        System.out.println("深圳大学各个学院的名称如下：");
        for(int i=0;i<collegeName.length;i++){
            if(i%4==0&&i!=0) System.out.println();//为了输出不占太多格，每四个学院一行输出
            System.out.print(college[i].getname()+" ");
        }
    }
}
public class first {
        public static void main(String[] args){
            SZU szu=new SZU();
            szu.getColledgeNumber();
            szu.getColledgeNames();
        }
}

(2).把SZU类和College类放进cn.edu包中。编写一个测试类，在源代码中用import语句引入cn.edu包中的所有类，并对它们所包含的方法进行测试。在报告中附上程序截图、运行结果截图和详细的文字说明。（图片cv不上来，orz）

这道题要用到上一题的两个类，并且这两个类和运行的测试类在不同的包。所以这道题首先分两个包，如下图：

源代码如下：

然后cn.edu包里面的类和类中需要被调用的方法都换成public前缀，否则无法跨包使用：

然后再在另一个包用import语句调用cn.edu包里面的类。之后测试类就可调用Teacher类和CSSE类创建对象和调用public对象方法了

测试结果如下：

可见测试类跨包调用成功。

(3).定义一个包，在该包中定义一个类并输出“我爱中国/I love China”字符串。在报告中附上程序截图、运行结果截图和详细的文字说明。

package love;

public class third {
    public static void main(String[] args){
        System.out.println("I love China");
        System.out.println("我爱中国!!!");
    }
}

我用的是Intellij IDEA，创建包的操作如下：

右击项目下的src（scoure code)->新建->软件包，然后命名，包就创建好了。

包中创建类的操作如下：

右击上面创建的love包->新建->java类，然后命名，类就创建好了。

代码（左）以及运行结果（右）：

(4).在一个包中定义一个默认访问权限控制的类DefaultClass，然后在该包以及另一个包中分别定义类来测试DefaultClass类中的private, default, protected和public数据成员的访问控制能力。在报告中附上程序截图、运行结果截图和详细的文字说明。

package DefaultClass;

 class DefaultClass {
    protected static String test_of_protected="I‘m prorected!";
    public static String test_of_public="I'm public!";
    static String test_of_default="I'm default!";
    private static String test_of_private="I'm private!";
}
package DefaultClass;

public class test_of_DefaultClass {
    public static void main(String []args){
        System.out.println("while they're in the same package");
        System.out.println("protected:"+DefaultClass.test_of_protected);
        System.out.println("public:"+DefaultClass.test_of_public);
        System.out.println("default:"+DefaultClass.test_of_default);
        //System.out.println("private:"+DefaultClass.test_of_private);
    }
}
package DefaultClass_new;
//import DefaultClass.DefaultClass;//调用不同包的import语句
public class fourth {
    public static void main(String []args){
        System.out.println("while they're in different package");
//        System.out.println("protected:"+DefaultClass.test_of_protected);
//        System.out.println("public:"+DefaultClass.test_of_public);
//        System.out.println("default:"+DefaultClass.test_of_default);
//        System.out.println("private:"+DefaultClass.test_of_private);
    }
}

源代码：

其中成员变量定义为静态是为了不用实例也能调用

同包的测试类，分别对protected、public、default成员变量输出

同包测试类输出结果为：

解注释后：

如图private报错，无访问权限

跨包测试：

源代码如下：

红红的报错，错误原因为：无法跨包调用DefaultClass

可得结论：

默认的DefaultClass类无法被跨包调用，因此无论DefaultClas中的成员变量是public还是protected修饰都无法被调用。

(5).在一个包中定义一个public访问权限控制的类PublicClass，然后在该包以及另一个包中分别定义类来测试PublicClass类中的private, default, protected和public数据成员的访问控制能力。在报告中附上程序截图、运行结果截图和详细的文字说明。

package publicClass;

public class publicClass {
    protected static String test_of_protected="I‘m prorected!";
    public static String test_of_public="I'm public!";
    static String test_of_default="I'm default!";
    private static String test_of_private="I'm private!";
}
package publicClass;

public class test_of_publicClass {
    public static void main(String []args){
        System.out.println("while they're in the same package");
        System.out.println("protected:"+publicClass.test_of_protected);
        System.out.println("public:"+ publicClass.test_of_public);
        System.out.println("default:"+ publicClass.test_of_default);
        //System.out.println("private:"+publicClass.test_of_private);
    }
}
package publicClass_new;
import publicClass.publicClass;
public class fifth {
    public static void main(String []args){
//        System.out.println("while they're in different package");
//        System.out.println("protected:"+publicClass.test_of_protected);
//        System.out.println("public:"+publicClass.test_of_public);
//        System.out.println("default:"+publicClass.test_of_default);
//        System.out.println("private:"+publicClass.test_of_private);
    }
}

源代码：

其中成员变量定义为静态是为了不用实例也能调用

同包的测试类，分别对protected、public、default成员变量输出

同包测试类输出结果为：

解注释后：

如图private报错，无访问权限

跨包测试：

源代码如下：

红红的报错，错误原因为；

可得结论：

public类可被跨包调用，但是只能使用跨包时只能使用里面的public成员

4 5题总体体会：default类型：只能在同包的类中调用。

protected类型：可以在任意包的子类中调用。

public：可以在任意包中调用。

private: 只能在自身类中调用。

所以，可见范围从小到大依次是 private < default < protected < public。

(6).编写一个抽象类Bird，它具有三个抽象方法flying, nesting, eating和singing。分别实现这个抽象类的三个子类Eagle、Dove和Sparrow。实现一个测试类，在测试类的main方法中分别使用这三个子类创建对象实体，然后通过它们的上转型对象变量调用flying()方法、nesting()方法、eating()方法和singing()方法。在报告中附上程序截图、运行结果截图和详细的文字说明。

package fifth;
public abstract/*抽象类*/  class Bird {
    abstract void flying();
    abstract void nesting();
    abstract void eating();
}
 class Eagle extends Bird{
    void flying(){
        System.out.println("Eagle is flying!");
    }
    void nesting(){
        System.out.println("Eagle is nesting!");
    }
    void eating(){
        System.out.println("Eagle is eating!");
    }
};
class Sparrow extends Bird{
    void flying(){
        System.out.println("Sparrow is flying!");
    }
    void nesting(){
        System.out.println("Sparrow is nesting!");
    }
    void eating(){
        System.out.println("Sparrow is eating!");
    }
};
class Dove extends Bird{
    void flying(){
        System.out.println("Dove is flying!");
    }
    void nesting(){
        System.out.println("Dove is nesting!");
    }
    void eating(){
        System.out.println("Dove is eating!");
    }
};
============================================================================
package fifth;
public class test_of_fifth {
    public static void main(String []args){
    Bird bird;
    System.out.println("Sparrow的上转型测试：");
    bird=new Sparrow();
    bird.eating();
    bird.flying();
    bird.nesting();
    System.out.println("Dove的上转型测试：");
    bird=new Dove();
    bird.eating();
    bird.flying();
    bird.nesting();
    System.out.println("Eagle的上转型测试：");
    bird=new Eagle();
    bird.eating();
    bird.flying();
    bird.nesting();
    }
}

抽象类：

三个子类Eagle、Dove和Sparrow分别如下：

测试类代码，用于Bird对象作上转换型变量

运行结果;

操作成功。

(7).一个四维向量由四个分量组成。四维向量的相加、相减和点乘等价于对应四个分量的相加、相减和相乘。比如两个四维向量（5,2,1,8）和（3,-1,0,-4），它们的和为（8,1,1,4），它们的差为（2,3,1,12），它们的点乘为（15,-2,0,-32）。编写一个接口Computable，它具有三个抽象方法add、minus和elementwiseProduct。编写一个Vector类，通过Computable接口实现四维向量的相加、相减和点乘。在报告中附上程序截图、运行结果截图和详细的文字说明。

package seven;

interface Computable {
    Vector add(Vector a);
    Vector minus(Vector a);
    Vector elementwiseProduct(Vector a);
}
public class Vector implements Computable{
    int x;    int y;    int z;   int w;
    Vector(int x1,int y1,int z1,int w1){
        x=x1;y=y1;z=z1;w=w1;
    }
    public Vector add(Vector a) {
        Vector b=new Vector(a.x+x,a.y+y,a.z+z,a.w+w);
        return b;
    }

    public Vector minus(Vector a) {
        Vector b=new Vector(x-a.x,y-a.y,z-a.z,w-a.w);
        return b;
    }

    public Vector elementwiseProduct(Vector a) {
        Vector b=new Vector(x*a.x,y*a.y,z*a.z,w*a.w);
        return b;
    }
    void print(){//输出函数
        System.out.print("("+x+","+y+","+z+","+w+")");
    }
}

================================================
package seven;

public class test_of_seven {
    public static void main(String[] args){
        Vector v1=new Vector(5,2,1,8);
        Vector v2=new Vector(3,-1,0,4);
        System.out.print("v1+v2=");
        v1.print();
        System.out.print("+");
        v2.print();
        System.out.print("=");
        v1.add(v2).print();
        System.out.println();
        System.out.print("v1-v2=");
        v1.print();
        System.out.print("-");
        v2.print();
        System.out.print("=");
        v1.minus(v2).print();
        System.out.println();
        System.out.print("v1*v2=");
        v1.print();
        System.out.print("*");
        v2.print();
        System.out.print("=");
        v1.elementwiseProduct(v2).print();
    }
}

(8).关于面向对象编程中的三个特性（封装、继承和多态），谈谈你的理解，并对封装或继承，通过类比、关联或演绎的方式，举一个在日常的学习生活中可以应用的例子（要求积极向上且能自圆其说）。

答：

（一）封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

1将类的某些信息隐藏在类的内部，不允许外部程序进行直接

2通过该类提供的方法来实现对隐藏信息的操作和访问。

3隐藏对象的信息。

4留出访问的对外接口。

特点：

• 对成员变量实行更准确的控制。
• 封装可以隐藏内部程序实现的细节。
• 良好的封装能够减少代码之间的耦合度。
• 外部成员无法修改已封装好的程序代码。
• 方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性。
• 便于修改，体高代码的可维护性。

• 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

注意事项：

​ 只支持单继承，即一个子类只允许有一个父类，但是可以实现多级继承，及子类拥有唯一的父类，而父类还可以再继承。

​ 子类可以拥有父类的属性和方法。

​ 子类可以拥有自己的属性和方法。

​ 子类可以重写覆盖父类的方法。

图中的食草动物和食肉动物都有动物的特性，可以理解为它们继承了动物的特性。

• 多态

Pet a = dog

Pet b = cat

Pet c = pig

        这里所表现的的就是多态。dog、cat、pig都是pet的子类，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——我们只有在运行的时候(喝的时候)才会知道引用变量所指向的具体实例对象。所以多态能让子类对象调用同一个父类传参方法而不需要写每个子类都写一个具体的父类方法。多态就是: 同一个引用类型，使用不同的实例而执行不同操作。

特点：

1，消除类型之间的耦合关系，实现低耦合。

​ 2，灵活性。

​ 3，可扩充性。

​ 4，可替换性。