Java作业

Java作业

Java 作业

• • 第一章
  • 第二章
  • 第四章
  • 第五章
  • 第六章

第一章

1、谈谈你过去学习编程语言的方法、经验和教训。
大一上学期我学习了c/c++这门课，章英老师讲的很详细，每周练习10道题，感觉大体上是掌握了的，但是部分（比如指针，数组）还是欠缺练习，理解也不是很到位。大一下学期，我学习了python，基本语法掌握以后，老师讲的很深入，后期又缺少练习，感觉不太好。
2、高级语言的编译型和解释型语言的编译执行过程有什么区别？
编译型语言的特点是先编译，后执行。需要通过“编译器”完成编译过程，结果交由CPU执行，依赖于平台。
解释型语言边编译，边执行，通过 “解释器”（Interpreter）完成解释执行的过程。而呈现结果的过程并不需要依赖平台。
3、Java语言都有哪些特点？与C,C++，Python有何不同？
简单安全：语法借鉴C/C++,消除指针，接口代替了多重继承，垃圾自动回收机制，提供了丰富的类库
面向对象：纯面向对象语言，复用，可扩展，可维护
多线程：应用程序在同一时间并发执行多项任务
动态性：动态加载类库，运行时创建对象，适应环境发展
分布性：访问不同网络主机的数据，在不同主机上执行相关 *** 作
跨平台，面向对象
1.c++、java和python都是面向对象的编程语言，但是c++和java都是强类型语言，而python是一种弱类型语言
2.垃圾回收机制：c++需要程序员收到回收，而java和python都有自己的垃圾回收机制GC。具体两者又有不同，python的垃圾收集机制主要是用的是引用计数方式。
3.c和java中变量的存储是真实值，而python总存储的是引用，所以python不用声明类型名称，它的输入均默认为字符串。
4.c++中用const来声明常量，java中使用final来声明，python中没有常量。
4、Java实现跨平台的原理是什么？
通过虚拟机
JDK、JRE、JVM分别是什么的简称，它们之间有何联系？
JVM:英文全称，Java Virtual Machine,是Java虚拟机，用来运行Java程序

JRE:英文全称，Java Runtime Environment,是Java运行时环境，里边包含了Java运行时所需要的类库。

JDK:英文全称，Java Development Kit,是Java开发工具包，里边包含了Java的开发工具。例如java,javac等。

JDK包含了Java的运行环境（即JRE）和Java工具。JRE包含了一个Java虚拟机（JVM）以及一些标准的类别函数库。总的来说，JDK、JRE、JVM三者都处在一个包含关系内，JDK包含JRE，而JRE又包含JVM。
具体地讲：
JDK = JRE + 开发工具集（例如Javac编译工具等）

JRE = JVM + Java SE标准类库

第二章

1、Java包含哪两大类数据类型？其中基本类型的每种类型的取值范围和默认值分别是多少？请编程验证。
基本数据类型和引用数据类型。

2、Java在什么情况下会发生整型溢出？请举例说明，并给出解决方案。
以下是摘自：http://calvin.javaeye.com/blog/91903，对于java内存泄漏的总结

（1）被生命周期极长的集合类不当持有，号称是Java内存泄漏的首因。
这些集合类的生命周期通常极长，而且是一个辅助管理性质的对象，在一个业务事务运行完后，如果没有将某个业务对象主动的从中清除的话，这个集合就会吃越来越多内存.

（2）Scope定义不对，这个很简单了，方法的局部变量定义成类的变量，类的静态变量等。

（3）异常时没有加finally{}来释放某些资源，JDBC时代也是很普遍的事情。

（4）另外一些我了解不深的原因，如：Swing里的Listener没有显式remove；内部类持有外部对象的隐式引用；Finalizers造成关联对象没有被及时清空等。
3、Java基本类型的包装类分别是哪些？其高频去间数缓存范围分别是什么？请选择一种包装类型编程验证其数据缓存特性。
byte → Byte
short → Short
int → Integer
long → Long
float → Float
double → Double
char → Character
boolean→ Boolean

Boolean：使用静态final，就会返回静态值
Byte：-128~127
Short：-128~127
Character：0~127
Long：-128~127
Integer：-128~127
4、什么是自动装箱，什么是自动拆箱，举例说明。
自动装箱： 当我们把一个基本类型的值（ 20），赋值给引用变量时候，系统可以 自动将它“包装”为相应的包装类的实例程序需要对象时， 如果给的只是一个基本类型的值， 系统会将它自动装箱为包装类的实例达到的效果： 有了自动装箱之后， 基本类型的值可以当成对象用—— 其实是【假相】 。
自动拆箱： 当我们需要一个基本类型的值时， 但实际上传入的包装类的对象。 系 统会自动把对象“剥”开，得到它的值。 达到的效果： 有了自动拆箱之后， 包装类的对象可当成基本类型的值 用——其实是【假相】 。

           //装箱的例子
           //装箱允许将值类型隐式转化成引用类型还是在Main方法里面
           int i = 2008;
           object obj = i;
           Console.WriteLine("1.i的值为{0}，装箱之后的对象为{1}",i,obj);
           i = 927;
           Console.WriteLine("2.i的值为{0},装箱之后的对象为{1}",i,obj);
           Console.ReadKey();

           //程序运行结果
           //1.i的值为2008，装箱之后的对象为2008.
           //2.I的值为927，装箱之后的对象为2008

          //拆箱例子
         //拆箱允许将引用类型显示转换为值类型，下面通过一个实例演示拆箱的过程
           int i = 112;
           object obj = i;
           Console.WriteLine("装箱 *** 作：值为{0},装箱之后的对象为{1}",i,obj);
           int j = (int)obj;
           Console.WriteLine("拆箱 *** 作,装箱的对象为{0},值为{1}", obj, j);
           Console.ReadKey();
        //程序运行后的结果
        //装箱 *** 作：值为112，装箱之后对象为112
        //拆箱 *** 作：装箱对象为112，值为112

5、int与Integer有什么区别，它们之间的相互转化是怎样的
请通过JDK文档自主学习Integer类，对主要方法进行测试。
转载https://blog.csdn.net/m0_48957269/article/details/108876760

int 属于普通数据类型，Integer是 int 所对应的包装类
①int转Integer
int a = 5;
Integer A = new Integer(a);或
Integer A = Integer.valueOf(a);
②Integer转int
Integer A = new Integer(5);
int a = A.intValue();
6、逻辑运算符&和&&的区别是什么？逻辑运算符&与位运算符&的区别是什么？请举例说明。
逻辑运算符 & 运算符左右两边的表达式首先被运算执行，再对两表达式的结果进行与运算

逻辑运算符 && 如果从左边的表达式中得到 *** 作数能确定运算结果，则不再对右边的表达式进行运算。

逻辑运算符&
参与运算的都是布尔值
x&y，x，y都为true时，结果为true

位运算符&
x&y，x,y按位进行与 *** 作

7、Java语言中可以采用什么语句跳出多重循环？请举例说明。
break lab; （跳出多重循环的外层循环），
其中：break是关键字；lab是用户定义的标号。

//lab:
           for(int i =0; i<2; i++) {
                for(int j=0; j<10; j++) {
                     if (j >1)  { 
                        break lab; 
                     }
                    System.out.println(“break");
                }
           }

输出结果：
break
break

第四章

1、对象与对象引用的区别是什么？请举例说明什么是对象？
引自《Java编程思想》中的一段原话：“按照通俗的说法，每个对象都是某个类（class）的一个实例（instance），这里，‘类’就是‘类型’的同义词。”对象通常与类联系起来，对象是对客观事物的抽象，类是对对象的抽象。它们的关系是，对象是类的实例，类是对象的模板。
什么是对象引用？
同样引用《Java编程思想》的一段话，“每种编程语言都有自己的数据处理方式。有些时候，程序员必须注意将要处理的数据是什么类型。你是直接 *** 纵元素，还是用某种基于特殊语法的间接表示（例如C/C++里的指针）来 *** 作对象。所有这些在 Java 里都得到了简化，一切都被视为对象。因此，我们可采用一种统一的语法。尽管将一切都“看作”对象，但 *** 纵的标识符实际是指向一个对象的“引用”（reference）。”　对象与对象引用有着本质上的区别。
2、对象作为参数传递的特点是什么？请举例说明
Java中对象作为参数传递，实际传递的是该对象的引用

public class test {
   public static void main(String[] args) {
       StringBuffer sb = new StringBuffer("Hello ");
       System.out.println("before change, sb is "+sb.toString());
       change(sb);
       System.out.println("after change, sb is "+sb.toString());
   }
   public static void change(StringBuffer stringBuffer){
       stringBuffer.append("world !");
   }
}

运行结果：
　　before change, sb is Hello
　　after change, sb is Hello world !
3、对象初始化顺序是怎样的？
先初始化父类的静态代码—>初始化子类的静态代码–>初始化父类的非静态代码—>初始化父类构造函数—>初始化子类非静态代码—>初始化子类构造函数
4.类的static字段与非static字段的区别是什么？static修饰的属性和方法有什么特点？
整理来源：原文链接：https://blog.csdn.net/weixin_46402869/article/details/108911003
类的static字段和非static字段区别
关于static和非static变量的区别。

1、static 修饰的变量称为类变量或全局变量或成员变量，在类被加载的时候成员变量即被初始化，与类关联，只要类存在，static变量就存在。非static修饰的成员变量是在对象new出来的时候划分存储空间，是与具体的对象绑定的，该成员变量仅为当前对象所拥有的。

2、static修饰的变量在加载的时候先于main方法加载在内存中的数据共享区-------方法区，而非static的变量在加载的时候，是要创建变量才加载在堆内存中的。

3、一个static变量单独划分一块存储空间，不与具体的对象绑定在一起，该存储空间被类的各个对象所共享。static变量值在方法区加载一次，而非static在创建对象时会加载很多次。每次创建都会拷贝一份。

4、对象在引用成员变量是直接通过类名.变量名调用，对象在引用实例变量时只能通过对象名.变量名调用。

5、在类中调用成员变量时直接调用或者以类名.变量名方式调用，实例变量则用this或者直接调用。

关于static方法和非static方法的区别
1、 static修饰的方法也和static一样。先于main方法被加载到方法区，以便共享使用。

2、静态的static方法中不能使用this或者super关键字，因为static方法是先于对象创建之前就已经加载的方法，是属于类的方法，而this和super指向的是本类的对象或者父类的对象，非静态的方法是属于对象的，方法里可以用this和super。

3、static方法可以用对象.方法名来调用，也可以用类名.方法名来调用。而非静态的方法只能创建对象后时调用。

4、static方法是加载一次，被所有的对象所共享。而非静态方法是有多少个对象就拷贝多少次，每个对象只能调用自己的拷贝的方法。

5、对象调用非静态的方法时，不考虑线程安全性的问题，而调用静态方法时，要考虑安全性的问题。因为静态方法只有一份。而对象的方法是自己有自己的。

6、同一个类中，静态方法中只能访问类中的静态成员。而非静态方法可以访问非静态的方法（使用类名调用，或者创创建本类的对象调用）。

什么时候用static？
当一个变量需要初始化加载时候,或者是经常被调用的时候可以加上static。

用static 修饰的方法可以直接被调用, 不用static修饰的需要先实例化一个对象后才可以被调用 。
比如 person这个类里面有一个方法public static add(){}
那么可以直接用person类调用 person.add();
5、final修饰符都有什么作用？
解:修饰属性时，该属性为常量。修饰方法时，该方法为最终方法，在子类中不能被覆盖。
6、Java中float[10]arr；语句正确吗？为什么？
不能写成 float[10] arr; 系统无法识别该语句给arr数组分配内存空间。
7、Java数组元素类型为基本类型和引用类型时，有什么不同？请举例说明
对于基本类型数组而言，数组元素的值直接存储在对应的数组元素中，因此，初始化数组时，先为该数组分配内存空间，然后直接将数组元素的值存入对应数组元素中。
如：

int[] a1={1,2,3,4,5};

引用类型数组的数组元素是引用，因此情况变得更加复杂：每个数组元素里存储的还是引用，它指向另一块内存，这块内存里存储了有效数据。
如：

MyClass[] mc=new MyClass[10];

第五章

1、Java的访问控制修饰符有哪些？各有什么访问权限？请对照第7页ppt的表格分别写程序验证。

2、子类对于从父类继承的哪些属性与方法是可见的？请分别写程序进行验证。

子类继承了父类的所有属性和方法， 但只有public、protected的属性和方法在子类是可见的。
子类在继承父类的时候，首先应该满足父类可被访问，例如当子类和父类不在同一个包当中时，父类修饰符必为public；在父类能被访问的前提下，凡是修饰符为public或是protected的父类属性成员或是方法能被子类所访问；private的属性成员或是方法则不能被直接访问。子类不能直接访问父类的private属性和方法，可以调用父类的公共方法来间接访问私有属性
3、什么是组合？有什么作用？请举例说明。

什么是重载？有什么作用？请构造各种重载示例。
方法名称（函数名）相同，参数类型 或 参数个数 不同。
作用：可以使用相同名字（一个名字）的方法实现不同的功能。

class Parent{
   public int Score(){
       return 3;
   }
   public int Score(int i){
       return i;
   }
}

*5、什么是覆写？有什么作用？覆写父类方法的条件有哪些？请举例说明。
当子类定义了和父类属性名称完全形同的时候，就成为属性的覆盖。

class Person{
  public String info = "Person";
}
class Student extends Person{
  //属性覆盖
  public String info = "Student";
}
public class Test{
  public static void main(String[] args){
      System.out.println(new Student().info);
  }
}

第六章

实验：利用IDE的debug功能给例6.4和例6.5的new语句设置断点，使用单步调试（step into/step over）跟踪子类对象实例化（初始化）的执行顺序，并总结该过程。

class Pare {
 int i = 3;

 Pare() {
     super();
 }
};

class Construct extends Pare {
 int i = 8;

 Construct() {
 }

 Construct(int num) {
     this();
 }

 public static void main(String args[]) {
     Construct ct = new Construct(9);
     System.out.println(ct.i);
     System.out.println(ct.getSuper());
 }

 int getSuper() {
     return super.i;
 }
}

实例化执行顺序总结：

1.为子类对象分配内存空间，对域变量进行默认初始化。
2.绑定构造方法，将new对象中的参数传递给构造方法的形式参数。
3.调用this或super语句，二者必居其一，也只有一。
4.进行实例变量的显式初始化 *** 作。
5.执行当前构造方法体中的程序代码。

2、如何实现两个对象之间互发消息，请举例说明。
使用引用的属性或方法其实都是调用对象的属性或方法，而消息概念的引入就是为了说明这样的过程。消息的实质就是引用向对象发出的服务请求，是对数据成员和成员方法的调用。下面列举能否发送消息的三个条件：
1.引用必须真实引用了特定的对象，否则会抛出NullPointerException异常。
2.访问对象必须定义了相应的属性或方法，否则编译不会通过。
3.被访问的属性或方法必须具有可访问的权限。
消息也就是相当于在遥控器和显示器之间架起沟通的桥梁。在面向对象语言中，消息把不同对象相互联系起来，共同完成特定功能。
实例代码：

class FighterPlane {
 String name;
 int missileNum;

 public FighterPlane(String _name, int _missleNum) {
     this.name = _name;
     this.missileNum = _missleNum;
 }

 public void fire() {
     if (this.missileNum > 0) {
         System.out.println("now fire a missile !");
         this.missileNum -= 1;
     } else {
         System.out.println("No missile left !");
     }

 }
}
class A {
 FighterPlane fp;

 public A(FighterPlane fpp) {
     this.fp = fpp;      //A对象中拥有了FighterPlane对象的引用
 }

 public void invoke() {
      //A对象发送消息给FighterPlane的对象
     System.out.println(fp.name);
 }
}public class Run {
 public Run() {
 }

 public static void main(String[] var0) {
     FighterPlane ftp = new FighterPlane("su35", 10);
      //产生A对象，并将ftp作为对象引用传入
     A a= new A(ftp);
     a.invoke();
 }
}

3、谈谈组合与继承的区别以及两者的使用场景（即什么时候宜用组合？什么时候宜用继承？）
组合：通过对象内部的属性引用来实现。使对象之间的耦合性较为松散。
继承：从已有的类派生出新的类。在不同的类中也可能会有共同的特征和动作，可以把这些共同的特征和动作放在一个类中，让其它类共享。因此可以定义一个通用类，然后将其扩展为其它多个特定类，这些特定类继承通用类中的特征和动作。继承是 Java 中实现软件重用的重要手段，避免重复，易于维护，易于理解。
组合就像房间里面的窗户、墙壁、地板、桌子、椅子等，他们之间并不存在结构上的相似性，只是功能上组合可以发挥更大的作用，但是单独是可以独立运行的。继承就像对房间进行拓展成为一栋楼，前面的零部件它都具备，但是如果没有房间，大楼是无法构建的，具有结构和功能上的关联。
显而易见，在不具有结构和功能上的相似性时，使用继承可以减少代码重复率，易于维护；在结构实现不同、功能“可叠加”时，使用组合无疑是优于继承的。
4、Java中的运行时的多态的含义是什么？有什么作用？请举例说明。
Java提供了两种多态机制——重载和覆盖。运行时多态指的是覆盖，在运行时根据输入参数动态选择不同的 成员方法执行，体现了一个类本身的多态性，使代码具有良好的拓展性。
举例：同样的红烧鱼，厨师老师的红烧方法传给厨师徒弟后，厨师徒弟在红烧方法上做了改动，这是红烧方法的重写，就相当于 java 的方法重写。
重写：

class Ct{
 void hongshao(int a){
     System.out.println("这是厨师老师的红烧int的方法");
 }
}

class Cs extends Ct{
 void hongshao(int a) {
     System.out.println("这是厨师徒弟的红烧int的方法");
 }
}

 class Cs extends Ct{
  void hongshao(int a) {
      System.out.println("这是厨师徒弟的红烧int的方法");
  }
  void hongshao(float b) {
      System.out.println("这是厨师徒弟红烧float的方法");
  }
  void hongshao(int a,float b) {
      System.out.println("这是厨师徒弟红烧int和float的方法");
  }
}

5、使用接口改写例6.8中的程序。

package bookcode.ex6.part6_8;

public interface Shape {
 double getArea();
 double getPerimeter();
 void show();
}
public class Circle implements Shape{
 private int r;
 public Circle(int _r){
     r = _r;
 }

 @Override
 public double getArea() {
     return r * r * Math.PI;
 }

 @Override
 public double getPerimeter() {
     return 2 * Math.PI * r;
 }

 @Override
 public void show() {
     System.out.println("Circle Area:" + getArea());
     System.out.println("Circle Perimeter:" + getPerimeter());
 }
}
public class Rect implements Shape {

 private int k;
 private int m;

 public Rect(int width, int height) {
     k = width;
     m = height;
 }

 public double getArea() {
     return (k * m);
 }

 public double getPerimeter() {
     return (2 * k + 2 * m);
 }
 @Override
 public void show() {
     System.out.println("Rect Area:" + getArea());
     System.out.println("Rect Perimeter:" + getPerimeter());
 }
}
import com.sun.tools.javac.file.SymbolArchive;

public class Triangle implements Shape{
 private int x, y, z, m;
 public Triangle(int _x, int _y, int _z){
     x = _x;
     y = _y;
     z = _z;
     m = (x + y +z) / 2;
 }
 @Override
 public double getArea() {
     return (Math.sqrt(m *(m - x) * (m - y) * (m - z)));
 }
 @Override
 public double getPerimeter() {
     return 2 * m;
 }
 @Override
 public void show() {
     System.out.println("Triangle Area:" + getArea());
     System.out.println("Triangle Perimeter:" + getPerimeter());
 }
}
public class RunShape{
 public static void main(String args[]){
     Rect rect = new Rect(5 , 6);
     Triangle triangle = new Triangle(3, 4, 5);
     Circle circle = new Circle(5);
     rect.show();
     System.out.println();
     triangle.show();
     System.out.println();
     circle.show();
 }
}

6、自定义一个类，覆写equals方法，以满足自身业务需求

class Person{
  private String name;
  private int age;
  public Person(String name,int age){
      this.name=name;
      this.age=age;
  }
  public String toString(){
      return this.name+"今年"+this.age+"岁";
  }
  public boolean equals(Object obj){//Object类可接受任何类
      if(obj==null){//判断是否为空，若不判断则会出先空指针异常（NullPointerException）
          return false;
      }
      if(this==obj){//判断是否在与自身比较（通过比较地址），若是则直接返回true
          return true;
      }
      if(!(obj instanceof Person)){//instanceof作用为判断其左边对象是否为右边对象的实例，此处为判断主方法中equals()方法括号中的对象是否为Person类
          return false;
      }
      //到达此处时必定是同类但不同地址的对象在比较
      Person per=(Person)obj;//向下转型，比较属性值
      return this.name.equals(per.name)&&this.age==per.age;//判定属性内容是否相等(易错点)
  }
}
class Student{}
public class Test{
  public static void main(String[] args) {
     Person per1=new Person("张三",18);
     Person per2=new Person("张三",18);
     Person per3=new Person("lisi",19);
     Person per4=null;
     Student stu=new Student();
     System.out.println(per1.equals(per1));//true
     System.out.println(per1.equals(stu));//false
     System.out.println(per1.equals(per3));//false
     System.out.println(per1.equals(per4));//false
  }
}

7、举例说明运算符instanceof的使用场景。
运算符的格式为：“a instanceofof A”，其中a为对象的引用，A为类。如果a为对象A的实例或A子类的实例，则会返回true；如果a为A父类的实例，则返回false；如果a对象的类和A没有任何关系，则编译不会通过。即instanceof比较的结果有三种：true、false、语法错误（编译不会通过）。

class Uncle{}
class Pare{}
class Pare1 extends Pare{}
class Pare2 extends Pare1{}
class Pare3{
   public class void main(String args[]) {
       Uncle u = new Uncle();
       Pare p = new Pare();
       Pare1 p1 = new Pare1();
       Pare2 p2 = new Pare2();
       if (p instanceof Pare) {
           System.out.println("p instanceof Pare");
       }
       if (!(p1 instanceof Pare1)) {
           System.out.println("p1 not instanceof Pare");
       } else {
           System.out.println("p1 instanceof Pare");
       }
       if (p2 instanceof Pare) {
           System.out.println("p2 instanceof Pare");
       }
       if (p1 instanceof Pare1) {
           System.out.println("p1 instanceof Pare1");
       }
       if (p2 instanceof Pare1) {
           System.out.println("p2 instanceof Pare1");
       }
       if (p1 instanceof Pare2) {
           System.out.println("p1 instanceof Pare2");
       } else {
           System.out.println("p1 not instanceof Pare2");
       }
       / *if (p instanceof Uncle) {
           System.out.println("p instanceof Uncle");
       } else {
           Ststem.out.println("p not instanceof Uncle");
       } * /
       if (full instanceof String) {
           System.out.println("null instanceof String");
       } else {
           System.out.println("null not instanceof String");
       }
   }
}

输出结果如图所示，如果去掉注释符“”，编译会出问题。

注意：如果对比较结果取反，必须加（）号，如本例的if(!(p1 instanceof Pare))。
8、谈谈抽象类与接口的异同以及两者的使用场景