大专Java基础系列----理论

最新推荐文章于 2024-07-17 21:40:42 发布

小二Type Code

最新推荐文章于 2024-07-17 21:40:42 发布

阅读量1.1k

点赞数 31

分类专栏： Java学习文章标签：学习

小二敲代码

本文链接：https://blog.csdn.net/2301_79996662/article/details/140101474

版权

Java学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前言

期末的复习资料，出自老师内容，仅供参考。

问答题

1、float和double型数据在赋值时有哪些注意事项？

float型数据在赋值时要在数字后面加一个大写F或者小写f ，

double型数据在赋值时在数字后面加一个大写D或者小写d 。

个人理解：不仅是Java，c语言也是如此。

2、什么是继承？

通过必要的说明能够实现某个类无需重新定义就拥有另一个类的某些属性和方法，并把这种关系称为继承，先定义的类称为父类，后定义的类称为子类，并且允许多层的继承关系。

3、请简述重载和重写的区别？

方法的重写Overriding和重载Overloading是Java多态性的不同表现。

重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。

如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

4、Java语言有哪些特点？什么叫Java虚拟机？

Java语言是一种简单的、面向对象的、分布式的、解释的、健壮的、安全的、结构中立的、可移植的、性能很优异的、多线程的、动态的语言。

Java虚拟机可定义为：运行经过编译的Java目标代码的计算机的实现。它既能运行Java应用程序也可以运行Java小应用程序。

5、什么是继承？什么是基类和子类？

继承性是面向对象程序设计语言的一个重要的特征，通过继承可以实现代码的复用。Java语言中，所有的类都是直接或间接地继承java.lang.Object类而得到的。被继承的类称为基类或父类，继承而得到的类称为子类。子类继承基类的属性和方法，同时也可以修改基类的属性和方法，并增加自己新的属性和方法。Java不支持多重继承，即一个子类不能拥有两个基类。

6、如何创建一个自定义异常？

Java语言允许用户定义自己的异常类，从而实现用户自己的异常处理。定义用户的异常类要继承Throwable类或它的子类，通常是继承Exception类。

7、标识符是Java程序的主要组成部分，每条语句中都会包含标识符，在Java中，标识可以包含哪些符合？

在Java中，标识符是以字母、下划线（_）或美元符（$）开头，由字母、数字、下划线或美元符组成的字符串。

8、请简述do-while循环语句思想？

在每次循环时，do-while语句先执行循环体，然后再计算布尔表达式的值，如果布尔表达式的值为true，就再次执行循环体，直到布尔表达式的值为false。do-while语句至少要执行一次循环体。

9、在Java中，什么是接口？如何使用接口？

接口是Java中的重要概念，可以将接口理解为一种特殊的类，接口由全局常量和公共的抽象方法组成。接口定义了若干抽象方法和常量，形成了一个属性集合，该属性集合往往对应某种功能，其主要作用是实现类的多重继承。

接口的声明只是给出了抽象方法，在定义了接口后，类就可以实现这个接口。类必须实现定义在接口中的方法，每个类能够自由决定方法具体实现的细节。可以通过关键字implements，使用特定格式的语句来实现接口。

10、请简述异常处理机制的执行过程。什么是自定义异常？

出现异常事件时，Java系统自动产生一个异常对象，然后将这个对象传递给Java运行时系统，这个例外产生和提交的过程称为抛弃例外（throw）;当Java运行时系统得到例外对象以后，它将会寻找处理这一例外的代码，找到能处理这一例外的方法以后，运行时系统把当前例外对象交给这个方法进行处理，这一过程称为捕获（catch）。

所谓自定义异常，就是定义一个继承自Exception类的子类。需要说明的是，一般情况下自定义异常类都是直接继承自Exception类，而不是继承自某个运行时的异常类

11、什么是流?什么是输入/输出流？什么是字节流和字符流，它们对应的基础抽象类分别是什么？

流：指的是所有数据通信通道中数据的起点和终点。

输入流：代表从外设流入程序的数据序列；

输出流：代表从程序流向外设的数据序列。

字节流：在输入输出过程中以字节为单位。InputStream,OutputStream

字符流：在输入输出过程中以字符为单位。Reader,Writer

12、Java语言有哪些特点？什么是Java虚拟机？

特点：简单性、面向对象、分布式处理、健壮性、结构中立、安全性、可移植性、解释性、高性能、多线程、动态

Java虚拟机：运行经过编译的Java目标代码的计算机的实现。

13、分析并说明下面这段程序中MyBox的各个成员。

class MyBox
{

   static int x,y;

   int width,height;

   MyBox()
    {
    x=0;
    y=0;
    width=0;
    height=0;
    }

   public void setPosition(int xPos,int yPos)
    {
    x=xPos; 
    y=yPos;
    }

   public void setSize(int w, int h) 
    {
    width=w;
    height=h;
    }

   static int getX() 
    {
    return x;
    }

   static int getY()
    {
    return y;
    }

   protected void draw(Graphics g) 
    {
    g.drawRect(x,y,width,height);
    }

}

类MyBox中包含类变量下x、y，实例变量width与height。

构成方法MyBox，实例成员方法setPostion，setSize，draw。类方法getX，getY。

14、什么是类的继承性？子类和父类有什么关系？

在java中，新类可以从现有的类中产生，产生的新类将保留现有类的变量和方法，并可根据需要对它们进行修改。新创建的类中还可以添加新的变量和方法，这些新增功能允许以统一的风格处理不同类型的变量。类的这种性能称为类的继承性。

使用继承方式创建的子类，不必写出全部成员变量和成员方法。只要声明这个子类是从哪个已定义的父类继承下来的，就可以引用父类的全部成员。但要注意子类不能继承父类中的private成员，除此之外，其他所有的成员都可以通过继承变为子类的成员。子类只能有一个父类。如果一个省略了extends，即没有说明类的集成关系，该类的父类默认为boject类。Object是在java.lang中定义的，它是所有类的始祖。

15. 事件处理及相关概念包括那些内容？什么叫做事件、事件源？

事件处理及相关概念包括事件、事件接口、监听器、注册（添加）监听器、事件类、事件接口中的方法、事件类的方法。

事件就是组件对用户的动作相应。而响应用户动作并产生事件的组件就是事件源。

判断题

1、Java的源代码中定义几个类，编译结果就生成几个以.class为后缀的字节码文件。（ √ ）

2、Java程序里,创建新的类对象用关键字new，回收无用的类对象使用关键字free。（× ）

在 Java 中，没有 `free` 关键字来回收无用的对象。Java 的内存管理是通过垃圾回收器自动完成的，当对象不再被引用时，会在适当的时候被垃圾回收器回收。

在 C/C++ 中，可以使用 `free` 函数来释放通过 `malloc` 或 `calloc` 分配的内存空间。但对于类对象，通常使用 `delete` 来释放通过 `new` 分配的对象内存。

3、Java有垃圾回收机制，内存回收程序可在指定的时间释放内存对象。（ × ）

在 Java 中，垃圾回收机制是自动运行的，但是它的运行时间是不可预测的，不能在指定的时间释放内存对象。 Java 的垃圾回收器会根据内存的使用情况和各种算法来决定何时回收不再被使用的对象，以释放内存空间。开发人员无法精确控制垃圾回收发生的具体时间点。

4、构造方法用于创建类的实例对象，构造方法名应与类名相同，返回类型为void。（ × ）

构造方法用于创建类的实例对象，构造方法名应与类名相同，并且构造方法没有返回类型，连 void 也不能写。

5、在异常处理中，若try中的代码可能产生多种异常则可以对应多个catch语句，若catch中的参数类型有父类子类关系，此时应该将父类放在后面，子类放在前面。（ √ ）

6、拥有abstract方法的类是抽象类，但抽象类中可以没有abstract方法。（√ ）

7、Java的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。（ × ）

在 Java 的默认坐标系统中，坐标原点位于容器的左上角

8、Java语言的标识符的命名是区分大小写的。（ √ ）

9、构造方法是类的一种特殊方法，它的方法名可以与类名不同。（ × ）

构造方法是类的一种特殊方法，它的方法名必须与类名相同。

10、Java中的异常就是程序编译或运行中所发生的异常事件。（ × ）

Java 中的异常是指在程序编译或运行过程中出现的非正常情况或错误事件

11．Java的标识符可以以数字开头（× ）

Java 的标识符不能以数字开头，必须以字母、下划线 _ 或美元符号 $ 开头

12. java中的包能减少名称冲突问题( √ )

13. Java不支持多重继承（√ ）

14. Java不支持构造的重载（× ）

构造方法重载指的是在一个类中可以定义多个构造方法，只要这些构造方法的参数列表不同（参数的个数、类型或顺序不同）。
通过构造方法的重载，可以为类的对象提供多种初始化方式，增加了类的灵活性和实用性。

15. Java类名首写字母一般为大写字母（ √）

16. 一个程序里有且只能有一个公共类，它就是主类( √ )

选择题

1、Java语言的类型是。（ A ）

A、面向对象语言 B、面向过程语言

C、汇编程序 D、形式语言

Java万物皆可为对象

2、（ C ）是不能被当前类的子类重新定义的方法。

A、抽象方法 B、私有方法 C、最终方法 D、构造方法

在 Java 中，最终方法（Final Method）是指使用 final 关键字修饰的方法。

一旦一个方法被声明为最终方法，那么它就不能在子类中被重写（覆盖）。这有助于确保某些关键方法的行为在继承体系中保持不变，增强了程序的稳定性和可预测性。

3、下列有关Java语言的叙述中，正确的是。（ B ）

A、Java是不区分大小写的

Java 是区分大小写的编程语言

B、源文件名与public类型的类名必须相同

C、源文件名其扩展名为.jar

在 Java 中，源文件的扩展名通常是 `.java` 。而 `.jar` 文件是 Java 的归档文件（Java Archive），它通常包含已编译的 `.class` 文件以及相关的资源文件等，可以方便地分发和部署 Java 程序。

D、源文件中public类的数目不限

在一个 Java 源文件中，`public` 类的数目只能有一个，并且源文件的名称必须与这个 `public` 类的名称相同（包括大小写）。如果源文件中有其他类，这些类不能被声明为 `public` 。

4、下列关于Java语言特点的叙述中，错误的是。 ( A )

A、Java是面向过程的编程语言

Java 是一种面向对象的编程语言。在面向对象编程中，重点是将数据和对数据的操作封装在对象中，通过对象之间的交互来实现程序的功能。而面向过程编程则侧重于通过一系列的步骤和函数来解决问题。

Java 具有面向对象编程的特性，如类、对象、封装、继承、多态等，这些特性使得 Java 能够更好地组织和管理复杂的程序逻辑，提高代码的可维护性、可扩展性和可重用性。

B、Java支持分布式计算

C、Java是跨平台的编程语言

D、Java支持多线程

5、如要抛出异常，应用下列哪种子句？（ B ）

A、catch B、throw C、try D、finally

在 Java 中，catch 用于捕获和处理 try 代码块中抛出的异常。
当 try 代码块中的语句在执行过程中发生异常时，程序会立即跳转到相应的 catch 代码块来处理该异常。catch 后面通常跟着一个括号，括号内指定要捕获的异常类型。

        在 Java 中，finally 块用于放置无论是否发生异常都一定会被执行的代码。
        它通常与 try-catch 语句一起使用。即使在 try 块中通过 return 语句提前返回，或者在 catch 块中处理了异常，finally 块中的代码仍然会被执行。
finally 块的主要用途包括：
        释放资源：例如关闭文件、释放数据库连接、关闭网络连接等，以确保资源得到正确释放，避免资源泄漏。
        执行必要的清理操作：无论程序执行过程中是否出现异常，都需要完成的一些清理或收尾工作可以放在 finally 块中。

6、下列哪个是面向大型企业级用容器管理专用构件的应用平台？（ A ）

A、J2EE B、J2ME C、J2SE D、J2DE

J2ME（Java 2 Micro Edition）：主要用于开发移动设备和嵌入式设备（如手机、PDA 等）上的应用程序。
J2SE（Java 2 Standard Edition）：是 Java 平台的标准版，用于开发桌面应用程序和普通的服务器应用程序。

J2EE（Java 2 Enterprise Edition）是一种利用 Java 2 平台来简化企业解决方案的开发、部署和管理相关的复杂问题的体系结构。

7、下面哪个方法是构造方法ConstA的重载？ ( A)

public class ConstA
{ 
    public ConstA (int x, int y, int z)
    {
    } 

}

A、 public ConstA(){}

B、 protected int ConstA(){}

C、 private int ConstA(int z, int y, byte x){}

D、 public void ConstA(byte x, byte y, byte z){}

8、下面关于变量及其范围的叙述，哪个是错误的？ (B)

A、私有成员变量只能被本类中的成员方法所访问。

B、实例变量用关键字static声明。

实例变量不用关键字 static 声明。

static 关键字用于声明静态变量，静态变量属于类，所有实例共享。

而实例变量是属于类的每个具体实例（对象）的变量，不用 static 关键字声明。

C、在方法中定义的局部变量在该方法被执行时创建。

D、局部变量在使用前必须被初始化。

9、根据下面给出的代码，判断哪个叙述是正确的。 ( C )

public class Test{

     static int a[] = new int[10];

     public static void main(String args[]){

         System.out.println(a[1]);      

     }

}

A、编译时将发生错误。 B、编译时正确但是运行是出错。

C、输出结果为0。 D、输出结果为 null 。

10、一个类中定义的成员变量只能被声明它的类和同一包中的类访问，则可以使用那个修饰符？( D )

A、public B、private C、protected D、没有修饰符

11．下面哪一个是正确的类的声明？（ D ）
　 A、 public void HH｛…｝ B、 public class Move()｛…｝
　C、 public class void number{} D、 public class Car｛…｝

12．在以下什么情况下，构造方法会被调用？（ B ）

A、类定义时 B、 创建对象时 C、调用对象方法时 D、使用对象的变量时

构造方法会在以下几种情况下被调用：

         1. 使用 `new` 关键字创建对象时。

         2. 当对象作为子对象被包含在另一个对象中进行初始化时。

         3. 通过反序列化或克隆机制恢复对象时，可能会间接调用构造方法。

         4. 在使用某些框架或技术（如依赖注入框架）创建对象并进行初始化的过程中。

13．Outer类中定义了一个成员内部类Inner，需要在main()方法中创建Inner类实例对象，以下四种方式哪一种是正确的？（ D ）

A、 Inner in = new Inner() B、Inner in = new Outer.Inner();

C、 Outer.Inner in = new Outer.Inner(); D、Outer.Inner in = new Outer().new Inner();

14．在类的继承关系中，需要遵循以下哪个继承原则？（B ）

A、多重　 B、单一　 C、双重　 D、不能继承

在类的继承关系中，通常需要遵循以下一些原则：

单一职责原则：子类应该只负责父类职责的一个特定子集，而不是承担过多不相关的职责。

里氏替换原则：子类对象能够替换父类对象，并且在程序运行过程中不会产生错误或异常。

依赖倒置原则：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。

接口隔离原则：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。

开闭原则：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。即应该通过扩展来实现变化，而不是修改现有代码

15、在Java语言中，以下哪个关键字用于在方法上声明抛出异常？（ C ）

A.try　　　B.catch　　　C.throws　　　D.throw

throw 用于主动抛出一个异常对象。

16.下列哪个叙述是正确的？（C）

A.子类继承父类的构造方法。

子类需要通过 `super` 关键字调用父类的构造方法来完成父类部分的初始化。

B.abstract类的子类必须是非abstract类。

`abstract` 类的子类可以是 `abstract` 类，也可以是非 `abstract` 类。但如果子类是非 `abstract` 类，那么它必须实现父类中所有的 `abstract` 方法。

C.子类继承的方法只能操作子类继承和隐藏的成员变量。

D.子类重写或新增的方法也能直接操作被子类隐藏的成员变量。

当子类中有与父类同名的成员变量时，父类的成员变量在子类中被隐藏。子类重写或新增的方法不能直接操作被子类隐藏的父类成员变量，要操作被隐藏的父类成员变量，需要通过父类的特定方法或者使用 `super` 关键字来访问。

17.对于下列 Dog 类，哪个叙述是错误的？（D）

A.Dog(int m)与 Dog(double m)是互为重载的构造方法

B.int Dog(int m)与 void Dog(double m)是互为重载的非构造方法

C.Dog 类只有两个构造方法，而且没有无参数的构造方法

D.Dog 类有三个构造方法

class Dog {

    Dog(int m){}

    Dog(double m){}

    int Dog(int m){ return 23;}

        void Dog(double m){}

}

构造方法具有以下特征：

        1. 方法名与类名相同：这是构造方法的重要标识，通过这种方式，编译器能够明确识别出这是一个构造方法。

        2. 没有返回值类型：构造方法不声明返回值类型，甚至不能使用 `void` 关键字。

        3. 主要用于对象的初始化：在创建对象时，构造方法被自动调用，用于为对象的成员变量赋初始值、执行必要的初始化操作等。

        4. 可以重载：一个类可以有多个构造方法，只要它们的参数列表不同。

        5. 系统默认提供无参构造方法：如果类中没有显式定义构造方法，编译器会为类提供一个默认的无参构造方法。但一旦显式定义了构造方法，默认的无参构造方法就不再自动提供。

18.将下列（A、B、C、D）哪个代码替换下列程序中的【代码】不会导致编译错误？（A）

interface Com{

    int M=200;

    int f();

}

class ImpCom implements Com{

    【代码】

}

A. public int f() {return 100+M;}

B. int f() {return 100;}

C. public double f() {return 2.6;}

D. public abstract int f();

缺少一个主方法,满足接口

19. 设已经编好了一个线程类MyThread，要在main()中启动该线程，需使用以下哪个方法（ B ）

A．new MyThread

B．MyThread myThread=new MyThread(); myThread.start();

C．MyThread myThread=new MyThread(); myThread.run();

D．new MyThread.start();

创建对象

20. 面向对象的三大特性不包括( D )

A.封装 B.继承 C.多态 D.消息通信

21.有一个类A，对于其构造函数的声明正确的是（B ）。

A．void A(int x){…} B．public A(int x){…}

C．AA(int x){…} D．int A(int x){…}

22.对于“int a[] = new int[3];”，下列哪个叙述是错误的？（B ）

A. a.length 的值是3 B. a[1]的值是1 C. a[0]的值是0 D. a[a.length–1]的值等于a[2]的值

填空题

1、开发与运行Java程序需要经过的三个主要步骤为编辑源程序 、编译生成字节码和解释运行字节码。

源程序是以.Java后缀命名文件

字节码是二进制计算机语言

解读二进制码

2、设 x = 2 ，则表达式 ( x + + )／3 的值是 0 。

在 Java 中，`x++` 表示先使用 `x` 的值，然后再将 `x` 的值增加 1 。

所以对于表达式 `(x++) / 3` ，首先计算 `2 / 3` ，由于两个操作数都是整数，所以结果进行整数除法，结果为 0 。然后 `x` 的值变为 3 。但表达式的最终结果是 0 。

3、若x = 5，y = 10，则x < y和x >= y的逻辑值分别为true 和 false 。

4、抽象(abstract) 方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。最终(final) 方法是不能被当前类的子类重新定义的方法。

抽象(abstract)方法

最终(final)方法

5、声明异常抛出用throws子句来完成声明，它包含在方法的声明之中。

6、顺序执行以下两个语句的输出结果是：11。

String s="我喜欢学习Java语言";
System.out.println(s.length());

在 Java 中，“length”这个词在不同的上下文中有不同的含义：

1. 如果是数组，使用`length`属性获取数组的长度。例如，对于数组`int[] arr = {1, 2, 3};`，可以通过`arr.length`获取其长度为 3 。

2. 如果是字符串（`String`类），使用`length()`方法获取字符串的长度。例如，对于字符串`String str = "hello";`，可以通过`str.length()`获取其长度为 5 。

7.如果一个方法不返回任何值，则该方法的返回值类型为 void

8.异常处理是由 try、catch和finally块三个关键字所组成的程序块。

9. 定义一个Java类时，如果前面使用final关键字修饰，那么该类不可以被继承。

在 Java 中，`final`关键字有以下主要用途：

1. 修饰变量： - 被`final`修饰的基本数据类型变量，其值不能被改变。 - 被`final`修饰的引用类型变量，其引用不能被重新赋值，但引用所指向的对象的内容可以改变。

2. 修饰方法：表示该方法不能被重写。

3. 修饰类：表示该类不能被继承。使用`final`关键字可以提高代码的安全性和可读性，防止意外的修改和扩展。

10.在Java中定义了两个类用来封装对字符串的操作，分别是String和 StringBuffer。

`String` 和 `StringBuffer` 是 Java 中用于处理字符串的类，它们有以下一些主要区别：

        1. 可变性 - `String` 对象是不可变的，一旦创建，其内容不能被修改。 - `StringBuffer` 对象是可变的，可以对其进行修改操作。

        2. 性能 - 在进行大量字符串拼接操作时，`StringBuffer` 的性能通常比 `String` 更好。因为 `String` 的每次拼接都会创建新的对象，而 `StringBuffer` 在内部进行缓冲区操作，减少了对象创建的开销。

        3. 线程安全 - `StringBuffer` 是线程安全的，多个线程可以安全地对其进行操作。 - `String` 本身不是线程安全的。

11.在Java中，图形用户界面简称GUI。

12.如果单击JFrame窗口中的一个按钮，能将窗口上JLabel组件中的文字内容改变，那么这个按钮上添加了 ActionListener监听器，并实现了监听器的actionPerformed方法。

ActionListener 是 Java 中的一个监听器接口，用于处理组件（如按钮）的动作事件。

当用户与支持动作事件的组件（如点击按钮）进行交互时，会触发动作事件。要使用 ActionListener ，需要实现其 actionPerformed 方法，在该方法中编写处理动作事件的逻辑。

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

public class ActionListenerExample {
    public static void main(String[] avg) {
        JFrame frame = new JFrame("ActionListener 示例");
        JButton button = new JButton("点击我");

        //应用ActionListener
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("按钮被点击了！");
            }
        });

        //窗口创建
        frame.add(button);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

13.所谓封装，是指在定义一个类时，将类中的属性私有化，即使用 private关键字修饰。

        在面向对象编程中，封装（Encapsulation）是将对象的属性和行为组合在一起，并对外部隐藏其内部实现细节的一种机制。

        封装具有以下几个重要特点和作用：

        1. 数据隐藏：将对象的内部数据（属性）隐藏起来，外部代码不能直接访问和修改这些数据，只能通过对象提供的公共方法（getter 和 setter 方法等）来获取和设置数据。这样可以保证数据的安全性和一致性，防止外部代码对数据的错误修改。

        2. 模块性：封装将相关的属性和方法组合成一个独立的单元（类），使得代码更具模块性和可维护性。每个类可以独立开发、测试和修改，而不会影响其他部分的代码。

        3. 信息隐藏：除了数据，对象的内部实现细节（如算法、复杂的计算过程等）也可以被隐藏，外部只需要知道如何使用对象提供的公共接口来完成所需的功能，而无需了解内部的具体实现。

例如，假设有一个表示“学生”的类 `Student` ，它的属性有 `name` （姓名）、 `age` （年龄）和 `grade` （年级）。可以将这些属性设置为私有，并提供公共的方法来获取和设置这些属性的值，从而实现封装。封装有助于提高代码的可读性、可维护性和可扩展性，是面向对象编程的重要原则之一。

编程题

1.对于求两个正数a和b 的平均值，可以使用算术平均公式(a+b)/2计算（算术）平均值，也可以使用几何平均公式 a×b 计算（几何）平均值。请编写两个类分别实现ComputeAverage接口，两个类重写接口方法分别用算术平均值和几何平均值计算a 、b的平均值。

//接口
interface ComputeAverage{
    //抽象方法
    double average (double a,double b);

}

//请完成题意中两个类的编写。
public class Example {
    public static void main(String[] args) {
       ComputeAverage computer;
       double a=12.3,b=45.6;//a、b为待计算的两正数
        //以下请使用接口回调，分别算出a、b两数的算术平均值和几何平均值，并输出相应结果
    }
}

代码实现：

//接口ComputeAverage
interface ComputeAverage {
	double average (double a, double b);
}
//算数平方根
class A implements ComputeAverage {
	public double average(double a, double b) {
		return (a + b) / 2;
	}
}
//几何平方根
class B implements ComputeAverage {
	public double average(double a, double b) {
		return Math.sqrt(a * b);
	}
}

public class Example {
	public static void main(String[] args) {
		ComputeAverage computer;
		double a = 12.3, b = 45.6;    // a、b为待计算的两正数
		computer = new A();
		System.out.printf("a和b的算术平均值：%.2f\n", computer.average(a, b));
		computer = new B();
		System.out.printf("a和b的几何平均值：%.2f", computer.average(a, b));
	}}

interface
//定义接口类

implements
//实现接口

运用计算深化学习接口的内容，在接口类里面定义抽象方法。

在类里面实现抽象方法。

2、使用GridLayout布局管理器编，使运行结果如下图：

代码实现

import java.awt.*;
import javax.swing.*;

public class GridLayoutDemo 
{ 
  public static void main(String args[])
  { 
    //创建一个JFrame的对象，叫frame
    JFrame frame=new JFrame("GridLayout布局");

    Container c=frame.getContentPane();
    //改变布局
    GridLayout g=new GridLayout(3,2,5,5);
    //生成3行2列窗口，按钮间隔为5，5
    c.setLayout(g);
    //添加在容器
    c.add(new JButton("1"));
    c.add(new JButton("2"));
    c.add(new JButton("3"));
    c.add(new JButton("4"));
    c.add(new JButton("5"));
    c.add(new JButton("6"));
    //创建窗口
    frame.setSize(200,250);//窗口大小
    frame.setVisible(true);//窗口可以显示
  }
}

 Container c=frame.getContentPane();

getContentPane 方法用于获取该窗口的内容面板（ContentPane ）。

然后将获取到的内容面板存储在 Container 类型的变量 c 中，以便后续在这个内容面板上添加组件（如按钮、文本框等）来构建界面。

复制重新生成

在 Java 中，`Container`是一个类，它是`java.awt.Component`的子类。`Container`表示一个容器，是一种特殊的组件，其主要作用是可以通过`add`方法添加其他组件（如按钮、文本框等）进来。

`Container`的常用子类包括`Window`和`Panel`。`Window`表示平时看到的各种应用程序的窗口，它可以作为一个独立的窗口显示出来。而`Panel`不能作为应用程序的独立窗口显示，它必须被添加到`Window`中或者其他的容器中才能显示。

GridLayout 即网格布局，它是以行列单元格的形式展示和排列内部控件的一种布局方式。

在 Java 的图形用户界面（GUI）编程中，GridLayout 类用于创建具有网格布局的容器。通过 GridLayout，可以将组件放置在规则的网格单元格中，实现类似表格的布局效果。

GridLayout 的特点包括：

组件放入后会变成方形，适合添加 JPanel 等组件，不太适合 JButton 这类组件；
使用虚细线将布局划分为行、列和单元格；
支持一个控件在行、列上交错排列；
可以设置行数、列数以及组件之间的水平和竖直距离；
布局策略相对简单，默认情况下，控件从左到右依次排列，当设置列数后，控件会自动换行排列。

GridLayout 类的构造函数有多种形式，例如：

public GridLayout()：默认只有一行，每个组件占一列。
public GridLayout(int rows, int cols)：指定容器的行数和列数。
public GridLayout(int rows, int cols, int hgap, int vgap)：除了指定行数和列数外，还可以设置组件之间的水平距离（hgap）和竖直距离（vgap）。

要指定某控件显示在固定的行或列，可以设置该子控件的android:layout_row和android:layout_column属性（在 Android 开发中）。若要设置某控件跨越多行或多列，可以将该子控件的android:layout_rowSpan或者layout_columnSpan属性设置为数值，并设置layout_gravity属性为fill。

此代码的思想逻辑是

继承JFrame窗口

创建一个JFrame的窗口对象叫frame

创建一个Container的变量c，获取面板

创建网格布局

添加按钮

创建窗口

3、请编写程序，实现计算“1+3+5+7+…+99”的值。

提示：

使用循环语句实现自然数1~99的遍历。
在遍历过程中，通过条件判断当前遍历的数是否为奇数，如果是就累加，否则不加。

代码实现：

Class Example
{
	public static void main(String[] args) 
	{
        public	int x = 1;
	      int sum;
	      sum = 0;
	      while(x<100)
	      {
		      if(x%2==1)
		      {
		        sum+=x;
		      }
		      x++;
	      }
		System.out.println(sum);
     }
}

 while

使用while循环计算结果

4.使用边界布局管理器编，使运行结果如下图：

代码实现;

import javax.swing.JFrame;
import javax.swing.*;
import java.awt.*;

public class BL extends JFrame{
    //创建BorderLayout布局（边界布局）管理器对象
    BorderLayout bl = new BorderLayout();
    //创建按钮JButton的对象
    JButton bN, bS, bW, bE, bC;

    public BL()  
    {
    	  super("布局管理器");
          setSize(300, 200);//窗口大小
	      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  //窗口可以关闭
         //创建5个按钮对象   
         bN=new JButton("北"); 
	     bS=new JButton("南");   
         bE=new JButton("东");
	     bW=new JButton("西");
         bC=new JButton("中");

         Container c = getContentPane();//创建内容面板
	     c.setLayout(bl); //设置内容面板的布局管理器为布局管理器

         //添加
         c.add("North", bN);       
         c.add("South", bS);
         c.add("East", bE);        
         c.add("West", bW);
		 c.add("Center", bC);
         setVisible(true);
    }
    public static void main(String[] args)
    {
         BL d = new BL(); 
     }  
}

JFrame
//窗口类

BorderLayout
//边界管理器类

setSize
//设置窗口大小

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//窗口可以关闭

 Container
//一个面板


getContentPane()
//创建内容面板

setVisible(true);
//显示窗口

5.在Eclipse中编写一个应用程序Task1，输出网格图案信息。如下图所示。

代码实现

public class Task1 {                           
	public static void main(String[] args) {   
		System.out.println("+---+---+");       
		System.out.println("|   |   |");       
		System.out.println("|   |   |");       
		System.out.println("+---+---+");       
	}                                          
}

直接打印

6. 使用流式分布管理器，实现下面的窗体。

代码实现：

import java.awt.*;//布局管理器
import javax.swing.*;

public class Krain extends JFrame{
	public static void main(String[] args){
		Krain k=new Krain();//创建一个窗体
	}

	Krain(){  
		//创建一个按钮（JButton）按钮组件
		JButton east=new JButton("东");
		JButton south=new JButton("南");
		JButton west=new JButton("西");
		JButton north=new JButton("北");
		JButton center=new JButton("中");	
	
		this.setLayout(new FlowLayout());//在添加前先将布局管理器设置为流式布局  

		this.add(east);
		this.add(south);
		this.add(west);
		this.add(north);
		this.add(center);

		this.setSize(400,300);		
		this.setLocation(500,500);  //窗体的位置，左上角的坐标
		this.setTitle("            简单的窗体");  //窗体标题
		this.setAlwaysOnTop(true);  //设置窗体置顶
		this.setIconImage(new ImageIcon("images/qq.gif").getImage()); //QQ图标
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //退出时关闭虚拟机
		this.setVisible(true);   //设置窗体可见性         
	}
}

FlowLayout
//流水式布局

setLocation
//窗口显示位置

setTitle
//窗口标题

setAlwaysOnTop
//窗口顶置

setIconImage(new ImageIcon("images/qq.gif").getImage());
//添加图片

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
//关闭窗口

this.setVisible(true);
//窗口可视化

综合题

利用所学知识，使用文件输入输出流，用Java语言实现，将文件test1.txt的内容复制到文件test2.txt中，请写出详细的实现代码。

代码实现

import java.io.*;
public class C610
{
    public static void main(String []args) {
        //创建对象C610，名叫test
        C610 test=new C610();
        //捕获异常IOException
        try {   
            test.RWFile("c:/test1.txt","c:/test2.txt");
	    }catch (IOException e) {
            System.out.println(e.toString());
        }
    }
    public void RWFile(String SouFile,String DesFile) throws IOException {
        //创建对象 FileInputStream、FileOutputStream并且名叫 fis、fos，
        //再用形参赋值进去给FileInputStream(SouFile)、FileOutputStream(DesFile)。
        FileInputStream fis=new FileInputStream(SouFile);
		FileOutputStream fos=new FileOutputStream(DesFile);
        //循环一个字符一个字符读取read()和输入字节write()
        int b;
        while((b=fis.read())!=-1) 
            fos..write(b)
        //关闭文件，释放内存
        fis.close();                 
		fos.close();
    }
}

创建RWFile的方法，形参数是两个String的类型对象。

并且抛出异常IOException

创建了一个 FileInputStream 对象 fis ，用于从指定的源文件（SouFile）读取数据。

创建了一个 FileOutputStream 对象 fos ，用于将读取的数据写入指定的目标文（DesFile）

使用一个 while 循环，通过 .read() 不断从源文件读取一个字节，并将其存储在变量 b 中。只要读取的值不为 -1（表示文件末尾），就将该字节通过 .write(b) 写入目标文件。

最后关闭文件。

String
//数据类型

IOException
//输入输出异常

try { }catch (异常 e) {}
//捕获异常

throws
//抛出异常

FileInputStream 
//读取目标文件数据

FileOutputStream 
//输入目标文件数据

while() 
//循环

.read()
//一个字节一个字节读取

.write();
//一个字节一个字节输入

.close(); 
//关闭文件

`C610 test = new C610();`

这种操作属于创建对象并进行对象引用的赋值操作。创建对象（`new C610()`）是根据类的定义在内存中分配空间并进行初始化。将创建的对象引用赋值给变量（`C610 test` 并通过 `=` 进行赋值），使得我们能够通过这个变量来操作和使用该对象。这种操作在面向对象编程中非常常见，用于实例化类以使用其功能和属性。

程序阅读题

请阅读下面程序，写出运行结果：

import java.io.*;
public class abc
{   
    public static void main(String args [ ])
    {   
         AB s = new AB("Hello!","I love JAVA.");
         System.out.println(s.toString( ));
    }
}
class AB {
  String s1;
  String s2;
  public AB(String str1, String str2)
  {
    s1 = str1; 
    s2 = str2;
  }
  public String toString( )
  {
    return s1+s2;
   }
}