其他题

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int arr[] = new int[100];
        int value = scanner.nextInt();
        int s = scanner.nextLine(); // 键盘输入多个字符
        int result = 0;
        System.out.println(result);
    }
}

int(直接去掉小数部分), double, char, String, float(必须在小数后面加f，否则默认为 double)

关于定义类或者接口：

//定义类
//public class Person {
//
//}

//定义抽象类 和 抽象方法
//public abstract class Person {
//    abstract void function1();
//}

//定义接口 和 方法
//interface Person {
//    void function1();
//}

//定义接口类名的类
//class PersonClass implements Person {
//    // 这里写包含接口中的方法 并实现功能
//}

//定义子类 继承父类
//class Son extends Person {
//    // 父类为抽象类时 必须包含父类中的抽象方法 并实现功能
//}

//定义主类名的类
public class Person {
    public static void main(String[] args) {
        //...
    }
}

对数据进行封装就是写数据对应的 getter 和 setter 。

起名：

• 不能使用关键字
• 不能数字开头
• 不能包含除了 _ 和 $ 之外的符号
• 不能带空格

定义数组

int arr[] = new int[100];
int arr[] = new int[]{1,2,3};
int arr[] = {1, 2, 3};

选择题 / 填空题

1、Java源文件的扩展名是 .java 。
2、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为 .class 。
3、HelloWorld .java编译成功后会生成一个 HelloWorld.class 文件。
4、开发与运行Java程序需要经过的三个主要步骤为 编译源程序、编译生成字节码、解释运行字节码 。
5、面向对象程序设计的基本特征是 抽象、封装、继承、多态 。
6、在Java语言中，体现多态性有两个方面：overloading (重载) 和 overriding (重写、覆盖）
7、package 语句要放在 文件开头 ，且必须放在 import 语句之前。
8、Java源程序的文件名必须与 public 类的类名相同。
9、Java源文件中可以有 多 个类。Java源文件中有 至多1 个类可以是public 类。
10、类是Java中基本的结构单位。
11、Java应用程序由若干个类所构成，它们可以分布在1个或多个源文件中，其中必须有1个源文件含有主类。
12、Java应用程序总是从主类的main方法开始执行；。
13、Java源文件如果含有主类，主类可以是public 类、默认（缺省）类。
14、String 类在 java.lang 包中。
15、Java的字符类型采用的是 Unicode 编码。
16、Java的各类数据所占用的长度与具体的软硬件平台环境无关。
17、在Java的基本数据类型中，char型采用Unicode 编码方案，每个编码占用2字节内存空间。无论是中文字符还是英文字符，都是占用2字节内存空间。
18、在Java的方法中，定义一个常量必须用关键字final 。
19、基本数据类型包括布尔型、整数型、浮点型、字符型。
20、浮点型数据根据存储长度和精度的不同，进一步分为double 和float 两种具体类型，double 的精度高于另一者。
21、Java中的默认浮点型是double.
22、字符串分为两大类，一类是字符串常量，使用String 类的对象表示：另一类是字符串变量，使用StringBuffer 类的对象表示。
23、StringBuffer 对象的字符序列可以修改，String 对象的字符序列不可以修改。
24、整型数组中的各元素的值必须是整型。
25、数组的下标从0开始。

26、Java语言的标识符是区分大小写的。
27、在Java中，\是转义字符，\n表示回车，\t表示tab键（制表键），\\表示\字符本身。
28、Java程序中的单行注释符是//，多行注释符是/**/。
29、即使条件不满足，do-while 循环体内的语句也至少执行一次。
30、for循环、while 循环、do-while 循环可以互相嵌套。
31、for循环可以产生死循环，while 循环可以产生死循环，do-while 循环可以产生死循环。
32、for循环的循环体可以为空，while 循环的循环体可以为空，do-while 循环的循环体可以为空。
33、方法中可以包含任意个return 语句。return 语句可以用来返回任何数据类型。
34、同一方法不可以同时用static 和abstract 修饰。

• static 关键字用于定义类级别的方法，而不是实例级别的方法。这意味着静态方法可以在不创建类的实例的情况下被调用。
• 静态方法属于类本身，而不是类的任何对象实例。
• abstract 关键字用于定义抽象类中的抽象方法。抽象方法没有具体的实现，它只是方法的声明，具体的实现由继承该抽象类的子类提供。不允许使用 abstract 和 final 修饰同一个方法。
• 抽象方法的目的是强制要求子类实现特定的方法。

35、方法的修饰（如果有）例如public 、abstract ,必须放在方法的类型的前面。
36、abstract 方法是一种仅有方法头，没有方法体的方法；这种方法只能存在于abstract 类和接口中。
37、在面向对象方法中，类的实例称为对象。
38、类声明class A 等价于class A extends iava.lang.Obiect 。
39、在Java中若定义抽象类则需要加关键字abstract 来修饰。
40、abstract 和final 不可以同时修饰同一个类。

• final 关键字用于定义最终类。最终类不能被其他类继承。

• 将类声明为最终的，意味着这个类是封闭的，不允许其他类通过继承来扩展它的功能。

41、abstract 类中可以有常量以及变量。
42、abstract 类中可以有abstract 方法，可以有非abstract 方法。
43、interface 中只可以有abstract 方法，不可以有非abstract 方法。
44、类中的实例方法不可以用类名直接调用，类中的静态方法可以用类名直接调用。
45、同一个类的对象使用不同的内存段。
46、静态成员使用相同的内存空间。
47、成员变量有默认值，局部变量没有默认值。

• Java为所有成员变量提供了默认值，以确保在对象被创建时，每个成员变量都有确定的初始状态。

• 局部变量是在方法内部定义的变量，它们的作用域仅限于方法内，并且只在方法被调用时存在。与成员变量不同，局部变量没有默认值。在Java中，局部变量必须在使用之前显式初始化，否则编译器会报错。

48、成员变量的名字可以和局部变量的名字相同。
49、类成员的权限修饰符的访问权限大小关系是- public >protected >private 。
50、方法的参数的名字不可以和方法中声明的局部变量的名字相同。

51、定义私有的成员函数或成员变量时，不必在类的开头部分集中定义。
52、定义私有的成员函数或成员变量时，利用关键字 private 定义。
53、被私有访问控制符private 修饰的成员变量，只能被该类自身所访问和修改。
54、被私有访问控制符private 修饰的成员变量，不能被与它在同一个包中的其他类、在其他包中的该类的子类所访问和修改。
55、String 类是final 类。
56、final 类可以有0_个子类，非final 类可以有多个子类。

57、除了java.lang.Obiect 类，任何一个类有且仅有一个父类。
58、除了java.lang.Object 类，任何一个类有_且仅有一_个父类。
59、在Java中，所有类的根类/父类/超类是java.lang.Object_.
60、子类和父类可以不在一个包中。
61、在Java中，关键字final 使类不能派生出子类。
62、子类可以声明和父类的成员变量同名的成员变量。
63、子类声明的成员的变量的名字和从父类继承来的成员变量的名字相同，子类就会隐藏掉所继承的成员变量。
64、一个类中可以有多个构造方法。
65、构造方法不可以用final 或static 修饰。
66、构造方法是类的一种特殊方法，它的主要作用是完成对类的对象的初始化工作，它的方法名必须与类名相同。
67、一般在创建新对象时，系统会自动调用构造方法，自动调用是通过关键字new实现的。
68、创建类的对象时，使用运算符new给对象分配内存空间。
69、Java语言对构造方法的返回类型的规定是：
70、Java语言规定构造方法可以重载。
71、即使一个类中未显式定义构造方法，也会有一个默认的构造方法，默认的构造方法的参数情况是：无参，函数体情况是：函数体为空。
72、子类不继承父类的构造方法。
73、子类构造方法中可以有多条super 调用父类的某个构造方法的语句。
74、如果在子类的构造方法中，没有显示地写出super 关键字来调用父类的某个构造方法，那么编译器就默认地有super ):调用父类的无参数的构造方法。
75、如果在子类的构造方法中，显示地写出了super 关键字来调用父类的某个构造方法，那么编译器就不再提供默认的super 语句。
76、super 关键字形成的语句必须是子类构造方法中的第1条语句。
77、子类中想使用被子类隐藏的实例成员变量或实例方法就需要使用关键字super 。
78、重载方法是指，一个类中定义两个方法，名字相同，参数不同。
79、this不可以出现在static 方法中，可以出现在实例方法和构造方法中。
80、子类可以定义和父类的方法同名的方法。
81、子类在方法重写时，不可以把父类的类(static )方法重写为实例方法。
82、子类在方法重写时，方法的访问权限不可以降低，但可以提高。
83、接口可以用public 修饰，不可以用private 或proteced 修饰。
84、接口中只可以有常量，不可以有变量。常量在接口中是隐式地被声明为公共（public）、静态（static）和最终（final）的，即常量被所有实现类共享，并且不能被修改。
85、接口中只可以有abstract 方法，不可以有非abstract 方法。

86、接口中的常量必须指定初值。
87、接口中的常量可以用接口名直接访问。
88、除了final 属性，接口中定义的常量还具有public 、static 属性
89、接口中的方法的访问权限一定都是_public _。
90、接口中的方法不可以用private 或protected 或final 修饰。
91、接口中void fo ;方法声明等价于- public abstract void f ();
92、接口的常量中可以存放实现该接口的类的实例的引用。
93、abstract 类可以实现接口。final 类可以实现接口。
94、类使用关键字implements 实现接口。
95、用来定义一个类继承父类的关键字是extends ,用来定义一个接口继承接口的关键字是extends 。
96、一个类可以继承1个类。一个类可以实现多个接口。一个接口可以继承多个接口。
97、一个类可以同时继承一个类和实现一个接口
98、一个类不可以重复实现同一个接口。
99、类和它所实现的接口不一定在同一个包里。
100、一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是abstract 类。

101、抽象类可以重写接口中的方法，也可以继承接口中的方法。
102、如果一个非abstract 类实现某个接口，该类必须重写接口中的全部abstract 方法。
103、如果一个非abstract 类实现某个接口，该类必须重写接口中的全部abstract 方法。
104、子接口将继承父接口中的全部方法和全部常量。
105、IntegerparseInt (");双引号内不是整数时会触发NumberFormatException 异常。
106、FileNotFoundException 类是_IOException _类的子类。
107、Throwable 类有两个重要的子类——Exception (异常)和Error (错误)。
108、所有异常的父类都是Throwable _类。
109、捕捉异常通过try-catch -finally 语句实现。
110、try-catch 语句可以由多个catch 组成。
111、在编写异常处理的Java程序中，每个catch 语句块都应该与ty语句块对应。
112、在异常处理中，将可能产生异常的语句放在try块中，用catch 语句去处理异常。
113、如果想在方法头抛出异常，那么需要用关键字throws :如果想在方法体内抛出异常，那么需要用关键字throw 。
114、FileReader 输入流按字符(char）i读取文件的内容，FileWriter 输出流按字符(char)写出数据。
115、FileOutputStream 输出流按字节(byte)写出数据。
116、程序如果需要读取程序“外部”的数据，可以创建指向外部的输入流。

117、程序如果需要将程序中数据，写入到程序“外部”，可以创建指向外部的输出流。
118、如果程序要读取一个文件，可以创建指向文件的FileInputStream 流、FileReader 流。
119、如果程序要写入一个文件，可以创建指向文件的FileOutputStream 流、FileWriter 流。
120、import java .sql*命令可以使我们在程序中创建数据库相关的对象。
121、import java .io.命令可以使我们在程序中创建输入输出流相关的对象。
122、import java .net.;命令可以使我们在程序中创建网络相关的对象。
123、线程状态可以分为五大状态：新建、就绪、运行、阻塞、死亡。
124、多线程系统中，多个线程之间有同步和互斥两种关系。

占用大小(单位：(单位：类型关键字bit)byte)取值范围默认值(单位：(单位：字位)节)布尔型boolean 1言false 或truefalse 字节型byte 81-128~1270短整型short 162-32768~327670整型int 324-231~231-10长整型long 648-263~263-1OL 单精度浮点型float 324大约士3.4X10380.0f双精度浮点型大约±1.7×double 648103080.0d字符型char 16216位Unicode '\O"
例1：在Java的基本数据类型中，char型采用Unicode 编码方案，每个编码占用2字节内存空间。
例2：在Java中，整型常量123占用的存储字节数是4。

简答题：
1、请简述Java语言的特点。
答：简单易学：Java风格类似于C++,但它摒弃了C++中复杂、不安全的特性；
面向对象：Java的设计是完全面向对象的，它具有面向对象的封装、继承和多态三大特点；
安全性：Java提供了字节校验器、文件访问限制机制、类装载器和运行时内存布局四级安全保证机制；
跨平台（体系结构中立）：Java程序能够在网络上任何地方执行；语言版本完全同一；具有字节代码与平台无关性；
多线程：Java环境本身就是多线程的，并且Java提供了对多线程的语言级支持；
动态性：Java所需要的类是运行时动态装载的，也可从网络载入。在分布环境中动态地维护应用程序和类库的一致性，类库的更新不需要重新编译程序，不影响用户程序的执行；
健壮性：Java提供强类型机制、异常处理、垃圾自动收集等，并且Java摒弃了指针。
除上述七点以外，Java还是一种分布的、解释的、可移植的、高性能的程序设计语言。
2、请简述Java中异常处理的机制。
答：首先Java的异常是面向对象的，一个Java的Exception 是一个描述异常情况的对象。当出现异常情况时，一个Exception 对象就产生了，并放到异常的成员函数里。
Java的异常处理是通过5个关键词来实现的：try,catch ,throw ,throws 和finally 。异常的处理结构由try,catch ,finally 三个块组成。其中try块存放将可能发生异常的Java语言，并管理相关的异常指针；catch 块紧跟在try块后面，用来激发被捕获的异常；finally 块包含清除程序没有释放的资源、句柄等。不管try块中的代码如何退出，都将执行finally 块。
Java语言可以不在方法中直接捕获，而用throw 语句将异常抛给上层的调用者。throw 语句就是来明确地抛出一个异常。首先你必须得到一个throwable 的实例句柄，通过参数传到catch 中，或者采用new操作符来创建一个。
3、Java中有哪几种访问控制符？并说明各自的作用范围。
答：private :仅在本类内的代码可以访问。
默认（无修饰符)：在同一包内的代码可以访问。
protected :在同一包内及其子类中的代码可以访问。
public ：所有包中的代码都可以访问。
4、请说明final 和static 各自的作用。
答：final :final 修饰的变量的值不可以被改变，final 修饰的方法不可以被重写，final 修饰的类不可以被继承。
static :static 修饰的成员变量称为静态变量，被类的所有的对象共享，可以通过类本身直接调用。static 修饰的方法称为静态方法，可以通过类本身直接调用。静态方法中不能访问类的非静态成员变量和非静态成员方法，静态方法中不可以有this。

5、什么是继承？
答：通过必要的说明能够实现某个类无需重新定义就拥有另一个类的某些属性和方法，这种关系就称为继承，并且允许多层的继承关系。先定义的类称为父类，后定义的类称为子类。
6、在Java中，实现代码复用主要有两种方式——继承和组合。请描述下这两种方式的区别。
答：继承：复用父类的属性和方法，在编译期间就确定了类的层次结构。在实际编程中，不好的设计经常会导致父类中带有子类的行为，导致父类子类互相依赖，丧失了重用的好处，破坏了封装。
组合：在运行期间通过对象之间的引用，动态确定彼此之间的关系，对象之间只能通过接口相互作用，对象的封装性就得到了良好的维护。在运行期间，任何对象都能够被替换为其他相同类型的对象。
总而言之，在Java中优先使用组合，而不是继承。
7、请简述重载和重写的区别。
答：方法的重写(Overriding )和重载(Overloading )是Java多态性的不同表现。重写是父类与子类之间多态性的一种表现，重载是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载。重载的方法是可以改变返回值的类型。
8、构造方法是特殊的方法，请简述它的特殊之处。
答：①构造方法名必须与类名相同；
②构造方法没有返回值，但不用void声明；
③构造方法不能被static 、final 、abstract 、synchronized 和native 等修饰符修饰；
④构造方法不能像一般方法那样用“对象。构造方法”显式地直接调用，应该用new关键字调用构造方法，给新对象初始化。
9、实例方法和类方法的区别是什么？
答：被static 修饰的方法称为类方法（或静态方法），而没有被static 修饰的方法称为实例方法。二者的调用方式不同。实例方法属于实例，必须通过实例调用；类方法属于类，一般通过类名调
用，也可以通过实例调用。
二者访问的成员不同。实例方法可以直接访问该类的实例变量和实例方法，也可以访问类变量和类方法；类方法只能访问该类的类变量和类方法，不能直接访问实例变量和实例方法。类方法要访问实例变量或调用实例方法，必须首先获得该实例，然后通过该实例访问相关的实例变量或调用实例方法。

10、说明抽象类和接口的异同点。
答：相同点：抽象类和接口都可以有抽象方法，都不可以被实例化。
不同点：①创建关键字不同：抽象类用关键字abstract 创建，接口用interface 关键字创建；
②成员变量不同：抽象类可以包含普通的变量，接口内的变量只能是final 的；
③方法不同：抽象类可以包含普通的方法，接口内只能有抽象方法且都是public 的；
④继承/实现不同：接口可以被继承，也可以被实现，而抽象类只能被继承。接口被接口继承时用关键字extends ,且可以多继承；接口被类实现时用关键字implements ,且可以多实现；抽象类被类继承时用关键字
extends ，且只能单继承。
11、在Java中怎样创建一个线程？
答：①定义类来实现Runnable 接口
class TestThread implements Runnablel
public void runo .
}
②继承Thread 类来实现
class TestThread extends Thread i
TestThread( String name)(super(name):starto }
public void runo
}
12、Error 和Exception 有什么区别？
答：Error 是程序无法处理的错误，比如OutoiMemoryError 、ThreadDeath 等。这些异常发生时，
Java虚拟机一般会选择线程终止。
Exception 是程序本身可以处理的异常，这种异常分两大类——运行时异常和排运行时异常。程序中应当尽可能去处理这些异常。
13、finally 的作用是什么？什么时候会被执行？
答：finally 代码块主要用来释放资源，比如I/0缓冲区、数据库连接。
无论是否抛出异常，finally 代码块总是会被执行。就算是没有catch 语句同时又抛出异常的情况下，finally 代码块仍然会被执行。

14、finally 、finalize 有什么区别？
答：finally 是异常处理语句结构的部分，表示总是执行。
finalize 是 java.lang.Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。
15、字节流与字符流有什么区别？
答：①字节流操作的基本单元为字节，字符流操作的基本单元为Unicode 码元；
②字节流默认不使用缓冲区，字符流使用缓冲区
③字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串。

开发 java 程序需要三个步骤：

1. 编写源文件
2. 编译源文件，生成字节码(多个 .class 文件) javac Hello.java
3. 加载运行字节码(main主类 -> Hello) java Hello

精度：byte < short < int < long < float < double

同一个数对a 进行两次异或运算，结果仍然是 a 。

类的成员类型中没有语句，语句必须放在方法中。

静态变量就是类变量。另一个是实例变量。实例方法可以调用该类中的实例方法或者类方法，类方法只能调用该类中的类方法。

方法重载：同名方法参数不同，类型不同。

package 语句作为 java 源文件的第一条语句。

上转型对象：B 是 A 的子类，B 创建一个对象，并将对象的引用放到 A 声明的对象中。

A a;
B b = new B();
a = b;

此时 a 就是 b 的上转型对象。不是父类创建的对象，是子类对象的”简化“形态，不关心子类新增的功能，只关心子类继承和重写功能。可以将上转型对象再强制转换到一个子类对象，这时子类对象又具备了子类的所有属性和功能。

抽象类不能用 new 创建对象，可以做上转型对象。如果一个非抽象类是某个抽象类的子类，那么必须重写抽象方法；如果子类也是抽象类，则可以继承也可以重写父类的抽象方法。

String.equals() 比较当前字符串对象的实体内容和参数指定的字符串s 的实体内容是否相同。而== 比较的是字符串的引用地址。

StringTokenizer(String s[, String delim]) 分析器(分割字符)，分析器对象的 nextToken() 可以逐个获取各个分割的字符。

线程的生命周期：1. 新建 start() 显示调用必须写 (2. 就绪 start() 显示调用必须写) 3. 运行(run() 不用写在代码中) 4. 中断 5. 死亡

Thread 类或者子类创建线程对象。

处理线程同步时，需要把修改数据的方法用关键字 synchronized 修饰。

外嵌类的成员变量和方法在内部类中均有效。

编程题

补全代码，最后提交完整代码。

class People {
    protected double weight, height;
    public void speakHello() {
       System.out.println("yayawawa");
    }  
    public void averageHeight() { 
       height = 173;
       System.out.println("average height:" + height);
    }
    public void averageWeight() {
       weight = 70;
       System.out.println("average weight:" + weight);
    }
}

class ChinaPeople extends People {  
    @Override
    public void speakHello() {
        System.out.println("你好，吃饭了吗");
    }
    @Override
    public void averageHeight() {
       height = 168.78;
       System.out.println("中国人的平均身高：" + height + "厘米");
    }
    @Override
    public void averageWeight() {
       weight = 65;
       System.out.println("中国人的平均体重：" + weight + "公斤");
    }
    public void chinaGongfu() {
       System.out.println("坐如钟，站如松，睡如弓");
    }
}

class AmericanPeople extends People {
    @Override
    public void speakHello() {
        System.out.println("How do you do");
    }
    @Override
    public void averageHeight() {
        height = 175;
        System.out.println("average height:" + height);
    }
    @Override
    public void averageWeight() {
        weight = 80;
        System.out.println("average weight:" + weight);
    }
    public void americanBoxing() {
        System.out.println("直拳，钩拳");
    }
}

class BeijingPeople extends ChinaPeople {
    @Override
    public void speakHello() {
        System.out.println("您好");
    }
    @Override
    public void averageHeight() {
        height = 170;
        System.out.println("北京人的平均身高：" + height + "厘米");
    }
    @Override
    public void averageWeight() {
        weight = 68;
        System.out.println("北京人的平均体重：" + weight + "公斤");
    }
    public void beijingOpera() {
        System.out.println("京剧是中国传统戏曲的一种形式");
    }
}

public class Example {
    public static void main(String args[]) {
        ChinaPeople chinaPeople = new ChinaPeople();
        AmericanPeople americanPeople = new AmericanPeople();
        BeijingPeople beijingPeople = new BeijingPeople();
        chinaPeople.speakHello();
        americanPeople.speakHello();
        beijingPeople.speakHello();
        chinaPeople.averageHeight();
        americanPeople.averageHeight();
        beijingPeople.averageHeight();
        chinaPeople.averageWeight();
        americanPeople.averageWeight();
        beijingPeople.averageWeight();
        chinaPeople.chinaGongfu();
        americanPeople.americanBoxing();
        beijingPeople.beijingOpera();
        beijingPeople.chinaGongfu();
    }
}

编写程序实现以下逻辑。

① 接口Animal具有一个抽象方法cry。

② 类Dog实现Animal接口，并实现cry方法。

③ 类Cat实现Animal接口并实现cry方法。

编写测试类，分别实现接口实现多态，利用方法的Animal接口参数实现多态。

// 接口Animal，包含一个抽象方法cry
interface Animal {
    void cry();
}

// 类Dog实现Animal接口，并实现cry方法
class Dog implements Animal {
    @Override
    public void cry() {
        System.out.println("汪汪汪");
    }
}

// 类Cat实现Animal接口并实现cry方法
class Cat implements Animal {
    @Override
    public void cry() {
        System.out.println("喵喵喵");
    }
}

// 测试类，用于演示多态
public class TestAnimal {
    public static void main(String[] args) {
        // 创建一个Animal类型的数组，存储不同类型的Animal对象
        Animal[] animals = new Animal[] {
            new Dog(), // Dog对象
            new Cat()  // Cat对象
        };

        // 遍历数组，调用cry方法，展示多态
        for (Animal animal : animals) {
            animal.cry(); // 多态调用，根据对象的实际类型调用相应的cry方法
        }

        // 演示使用Animal接口引用调用具体实现类的cry方法
        Animal myDog = new Dog();
        myDog.cry(); // 输出：汪汪汪

        Animal myCat = new Cat();
        myCat.cry(); // 输出：喵喵喵
    }
}

在子类的构造方法中使用 super 调用父类的构造方法

class A {
    int x, y;
    A () {
        x = 100;
        y = 200;
    }
    A(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
class B extends A {
    int z;
    B (int x, int y) {
        super(x, y);
        z = 300;
    }
    B () {
        super();
        z = 800;
    }
    public void f() {
        System.out.println(x, y, z);
    }
}
public class Example {
    public static void main(String[] args) {
        B b1 = new B (10, 20);
        b1.f();
        B b2 = new B();
        b2.f();
    }
}

接口回调

interface ShowMessage{
    void showTradeMark();
}
class TV implements ShowMessage {
    @Override
    public void showTradeMark() {
        System.out.println("我是电视机");
    }
}
class PC implements ShowMessage {
    @Override
    public void showTradeMark() {
        System.out.println("我是电脑");
    }
}

public class Example {
    public static void main(String[] args) {
        ShowMessage sm;
        sm = new TV();
        sm.showTradeMark();
        sm = new PC();
        sm.showTradeMark();
    }   
}

使用接口

// 忽略，都大同小异…

冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 1, 4, 2, 8};
        bubbleSort(arr);
        System.out.println("Sorted array: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Swap arr[j] and arr[j + 1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}