实验三 Java面向对象高级语法实验2-优快云博客

本文链接：https://blog.youkuaiyun.com/hackermengzhi/article/details/139064520

实验三 Java面向对象高级语法实验2
一、实验学时
4学时
二、实验目的
（一）掌握自动装箱与拆箱的原理；
（二）掌握枚举的定义及使用；
（三）掌握注解的使用；
（四）掌握Lambda表达式的使用。
三、预习要求
了解自动装箱和拆箱、枚举、注解、lambda表达式的概念。
四、实验内容
（一）请打印下列程序输出结果，并思考自动装箱和拆箱在java中的好处。
public class AutoPackingTest
{
public static void main(String[] args)
{
Integer A = 3;
int a = A;
System. out.println(a);

	Integer A1 = 3; 
	System.out.println(A == A1);  
	
	A = 129;A1 =129;
	System.out.println(A == A1);
	} 
}

其中a、A1与A是怎样的对应关系？
A是a的包装类，a是基本数据类型，A1是另一个包装类
对打印处理的结果加以说明？
当i的值位于[-128,127]的时候，会直接返回Integer缓存数组中相应对象的引用，如果i大于127或小于-128，会重新创建一个Integer实例，并返回。
-128 ~ 127的在Integer频率高，所以设置为同一个对象
Java中有哪些基本数据类型以及其对应的包装类？

（二）观察下列程序的输出结果，掌握枚举的定义及使用。
enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
public class EnumTest {
public static void main(String[] args) {
// 创建枚举数组
Day[] days = new Day[] { Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY,
Day.THURSDAY, Day.FRIDAY, Day.SATURDAY, Day.SUNDAY };
// 打印枚举常量的序号以及枚举值
for (int i = 0; i < days.length; i++) {
System.out.println(“day[” + days[i].ordinal() + “]:”
+ days[i].name());
}
// 通过compareTo方法比较,实际上其内部是通过ordinal()值比较的
System.out.println(“day[1] VS day[2]:” + days[1].compareTo(days[2]));
}
}

枚举的本质是什么？
本质为用户自定义分类有限集合常量的方法。在Java中，枚举是一个特殊的类，一般表示一组常量。可以通过enum定义枚举变量，各个常量使用逗号来分隔。

（三）编写枚举程序，其中有四种颜色（RED、GREEN、WHITE、YELLOW），每种颜色有自己的属性（名字和索引），需要实现构造方法、属性的get/set方法和通过索引获取名字的方法，以及重写toString（）方法来打印索引加名字。之后编写一个测试类，测试这些方法，掌握枚举的定义及使用。
package sample;
enum Color{
RED(“红色”, 1), GREEN(“绿色”, 2), WHITE(“白色”, 3), YELLOW(“黄色”, 4);
private String name;
private int number;
// 构造方法
Color(String name, int index) {
this.name = name;
this.number = index;
}
//属性的get方法
public String getName(){
return name;
}
//属性的set方法
public void setName(String name) {
this.name = name;
}
//属性的get方法
public int getNumber(){
return number;
}
//属性的set方法
public void setNumber(int number) {
this.number = number;
}
//重写toString（）方法来打印索引加名字
public String toString() {
return this.getName()+“:”+this.getNumber();
}
}

public class myenum {
public static void main(String[] args) {
/// 创建枚举数组
Color [] color = new Color[] { Color.RED, Color.GREEN, Color.YELLOW, Color.WHITE};
//初始
System.out.println(“初始值：”);
for(int i = 0; i<color.length; i++) {
System.out.println(color[i].toString());
}
color[2].setName(“蓝色”);//变换属性
color[2].setNumber(611);//变换属性
//变化后
System.out.println(“变化后：”);
for(int i = 0; i<color.length; i++) {
System.out.println(color[i].toString());
}

}

（四）请说明注释与注解的区别并举例说明？编写程序使用@override和@Deprecated注解。
注解：与类、接口、枚举是在同一个层次，用一个词描述注解，它是一种描述数据的数据。所以，注解就是源代码的元数据。
注释：是对源代码作介绍、评议或说明的文字。
package sample;

class test{
String name;
test(){
name = “”;
}
public void set(String n){
name = n;
}
public void draw1() {
System.out.println(name);

}
public void drawOut() {
	System.out.println(name);
}

}
class texts extends test{
//// //重写检错
// @Override
// public void draw1() {
// name = “我重写辣！”;
// System.out.println(name);
// }
//// //重写检错
// @Override
// public void draw2(){
// name = “我,原!”;
// }
//弃用方法
// @Deprecated
// public void darw1() {
// name = “我免费辣！”;
// System.out.println(name);
// }
//
//}
public class Text {
public static void main(String[] args) {
texts ch =new texts();
ch.set(“到沈阳辣!”);
ch.draw1();

}

@Override : 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
@Override

@Deprecated

（五）运行下列代码并打印输出结果，理解Lambda表达式

interface Addable{
int add(int a,int b);
}

public class LambdaExpressionExample3{
public static void main(String[] args) {

    // Multiple parameters in lambda expression  
    Addable ad1=(a,b)->(a+b);  
    System.out.println(ad1.add(10,20));  
      
    // Multiple parameters with data type in lambda expression  
    Addable ad2=(int a,int b)->(a+b);  
    System.out.println(ad2.add(100,200));  
}

}

（六）使用Lambda表达式改写下列代码并打印输出结果。

interface Drawable{
    public void draw();
}
public class LambdaExpressionExample {
    public static void main(String[] args) {
        int width=10;

        //without lambda, using anonymous class
        Drawable d=new Drawable(){
            public void draw(){
System.out.println("Drawing "+width);
}
        };
        d.draw();
    }
}

（七）使用Lambda表达式编写一个函数式接口，内含唯一的抽象方法makeFood，且无参数，无返回值。分别使用内部类方法和Lambda的标准格式调用invokeCook方法，打印"享用美食！"字样。
（1）内部类
package sample;
interface FoodTest{
abstract public void makefood();
}
public class InnerClassTest {
public static void main(String[] args) {
FoodTest n = new FoodTest()
{
@Override
public void makefood() {
invokeCook();
}//重写方法，包含方法invokeCook();
public void invokeCook()
{
System.out.println(“享用美食！”);
}

	};
	n.makefood();
}

}
（2）使用Lambda的标准格式
package sample;
public interface FoodTest{
public void makefood();
}
public class LambdaTest {
public static void main(String[] agre) {
invokeCook(() -> {
System.out.println(“享用美食！”);
});
//Lambda的标准格式调用invokeCook方法
}
public static void invokeCook(FoodTest c){
c.makefood();
}

}

五、实验注意事项
（一）注意自动装箱和拆箱过程中数据的溢出情况
（二）Java为枚举类型提供了一些内置的方法，同时枚举常量还可以有自己的方法。可以很方便的遍历枚举对象。
（三）注意Lambda表达式与匿名内部类的关系。
六、思考题
（一）Integer A = 5; A = A+ 1; 经历了什么过程？
装箱、拆箱、装箱

（二）Enum是所有 Java 语言枚举类型的公共基本类（注意Enum是抽象类）；它的常见方法有哪些？
int compare(E o)比较此枚举与指定对象的顺序
ClassgetDeclaringClass()返回与此枚举常量的枚举类型对应的Class对象
String name()返回此枚举常量的名称，在其枚举声明中对其进行声明
int ordinal()返回枚举常量的序号
String toString( )返回枚举常量的名称，它包含在声明
static <T extends Enum>T valueOf(classenumType,String name)

（三）请描述Java提供的5个基本的注解及作用。
@Override - 当我们想要重写父类中的方法时，我们需要使用该注解去告知编译器我们想要重写这个方法。这样当父类中的方法移除或者发生更改时编译器将提示错误信息。

@Deprecated - 当我们希望编译器知道某一方法不建议使用时，我们应该使用这个注解。Java在javadoc 中推荐使用该注解，我们应该提供为什么该方法不推荐使用以及替代的方法。

@SuppressWarnings - 这个是告诉编译器忽略特定的警告信息，它会一直作用于该程序元素的所有子元素，如果使用@SuppressWarnings修饰某个类取消显示某个编译器警告，同时又修饰该类里的某个方法取消显示另一个编译器警告，那么该方法将会同时取消显示着这两个编译器警告。

@SafeVarargs - 提醒开发者不要用参数做一些不安全的操作,它的存在会阻止编译器产生 unchecked 这样的警告。当开发者不想看到这样的警告，就可使用@SafeVarargs修饰引发该警告的方法或者构造器。

  @FunctionalInterface -用来指定某个接口必须是函数式接口，而且它只能用来修饰接口，不能修饰其它元素。

（四）什么是函数式接口？
如果接口中只有一个抽象方法，那么该接口就是函数式接口

（五）Lambda表达式由哪三部分组成？
①形参列表：形参列表可以省略形参类型。若形参列表中只有一个参数，则，可以省略形参列表的圆括号()。
②箭头（->）：由英文的中划线和大于号组成。
③代码段：若代码段中只有一条语句，则可以省略花括号{};若代码段中只有一条return语句，则可以省略return关键字；若代码段中只有一条没有return的语句，则可以自动返回这条语句的值