Java 2 实用教程题库

Java 2 实用教程题库

  1. java程序运行javac, java命令的作用?
   javac: javac为Java编译器, 用于将 .java文件编译为 .class字节码文件. 
   java: java命令用于启动jvm虚拟机并执行已编译好的.class字节码文件. 
  1. java中常用类Integer, Float, String类名, String中equals方法以及==方法
   java 中常用类: 
       Integer, Float, String类
       // 常用方法估计不许要看, 只需记得常用类有哪些即可
       Integer 类常用方法: 
   		intValue(): 返回该 Integer 对象的 int. 
   		parseInt(String s): 将字符串转换为 int. 
   		valueOf(String s): 返回一个表示指定字符串值的 Integer 对象. 
   		compareTo(Integer anotherInteger): 比较两个 Integer 对象的大小. 
       Float 类常用方法: 
       	floatValue(): 返回该 Float 对象的 float. 
   		parseFloat(String s): 将字符串转换为 float. 
   		valueOf(String s): 返回一个表示指定字符串值的 Float 对象. 
        String 类常用方法: 
       	length(): 返回字符串的长度. 
   		substring(int start, int end): 提取字符串的子字符串. 
   		charAt(int index): 返回指定位置的字符. 
   		equals(String anotherString): 比较两个字符串是否相等. 
   		equalsIgnoreCase(String anotherString): 忽略大小写比较两个字符串是否相等. 
   		toLowerCase(): 将字符串转换为小写. 
   		toUpperCase(): 将字符串转换为大写. 
    String中equals方法以及==方法: 
       equals() 方法是 String 类的一个实例方法, 用于比较两个字符串的内容是否相等. 它会比较字符串的每个字符是否相同, 并且考虑到字符的顺序. 注意: equals() 是内容比较, 它返回 true 当且仅当两个字符串内容完全相同. 
   	== 是一个引用比较运算符, 用于比较两个对象的内存地址(引用是否相同). 在字符串的情况下, == 比较的是两个对象的引用是否指向同一个内存地址. 
       
  1. java中如何定义一维数组, 二维数组
   一维: int[] arr = {1,2,3} // 一行三列. 
   二维: int[][] arr = {{1,2,3},{4,5,6}}; // 两行三列. 
  1. java中基本不同数据类型混合运算, 类型的转换.
   java中基本不同数据类型混合运算: 
   	运算中的所有操作数会提升到运算中最高的数据类型. 
   	小于 int 的数据类型(byte, short, char)在运算时会自动提升为 int. 
   	优先级 byte -> short -> int -> long -> float -> double
       // 以下为示例
       public class Main {
       public static void main(String[] args) {
           byte b = 10;
           short s = 20;
           int i = 30;
           float f = 40.5f;
           float result = b + s + i + f; // 自动提升到 float
           System.out.println("结果: " + result); // 输出: 100.5
       }
   }
   类型的转换: 
       当较小范围的数据类型赋值给较大范围的变量时, Java 会自动进行类型转换, 也就是隐式转换. 
   	不会出现数据丢失. 
   	强制类型转换(显式转换)
       	目标类型 变量名 = (目标类型) 要转换的值;
       	// 以下为示例 将 double 转换为 int 以此类推
   		public class Main {
       	public static void main(String[] args) {
           double d = 99.99;
           int i = (int) d; // 强制转换
           System.out.println("double 转为 int: " + i); // 输出: 99
       }
   }
  1. 掌握基本算术运算符+, -, ×, /, %, ++, –
   public Main {
       public void static main(String[] args){
           int add = 1 + 1; //结果为 2 加法运算
           int less = 1 - 1; // 结果为 0 减法运算
           int cf = 1 * 1; // 结果为 1 乘法运算
           int div = 1 / 1; // 结果为 1 除法运算
           int qy = 1 % 1 // 结果为 0 取余运算
           int test = 1; //创建变量并赋值
           ++test //结果为 2 , 自增运算, 先计算后赋值 
           test++ //结果为 2 , 自增运算, 先赋值后计算
           test = 1 // 重新赋值
           --test //结果为 0 , 自减运算, 先计算后赋值
           test-- //结果为 0 , 自减运算, 先赋值后计算
           // 自增运算常用于循环计算
       }
   }
  1. 循环语句中break 与continue的区别.
   break:  
   	跳出当前循环并中止整个循环. 
   
   continue:  
   	跳过本轮循环剩余代码, 并进入下一轮循环. 
  1. 成员变量与局部变量的使用, 区别
   成员变量:  
       成员变量指在类中定义('类中方法外')的变量, 其不在任何方法, 函数, 代码块中仅在类中, 其作用域在类中可被类中任意方法访问. 生命周期与对象绑定即对象被销毁时其跟着被销毁
   局部变量:  
       局部变量指在方法, 构造方法, 代码块中定义的变量, 其作用域仅在其处于的方法或代码块中, 局部变量无默认值, 需显示绑定值否则会编译错误. 生命周期在方法或代码块执行结束被销毁的时候跟着销毁. 局部变量无法使用 private protected public 修饰, 但可以使用 final 修饰. 
   
  1. 如何定义构造方法, 构造方法什么时间调用
   构造方法名称需与类名相同, 构造方法无返回值. 其分为有参构造与无参构造, 其可以重载即参数不同. 
   // example
   class Example {
       int tmp;
       Example(){
           this.tmp = 1;
           System.out.printf("无参构造");
       }
       Example(int tmp){
           this.tmp = tmp;
           System.out.prinft("有参构造");
       }
   }
   Example ex1 = new Example(); // 触发无参构造
   Example ex2 = new Example(1); // 触发有参构造即
   构造方法在创建对象时自动调用, 通过new关键字创建对象时执行
   如果一个子类继承了父类, 那么父类对象的无参构造方法将优先被调用接着再调用子类方法, 当然也可使用 super() 关键字调用父类构造方法. 其位置必须为子类构造方法第一条语句. 
  1. 继承的特性, 抽象类, 抽象方法的特性
   继承的特性: 
   	  继承是面向对象编程中的重要特性之一, 它允许一个类(子类)从另一个类(父类)继承属性和方法, 从而实现代码的重用和扩展. 
   	  属性和方法继承: 
   	 	 子类继承父类的非私有(private)属性和方法. 
   	 	 子类可以直接使用父类的方法, 也可以通过方法重写(override)实现自己的版本. 
   	  代码重用: 
   		 子类可以复用父类中的代码, 无需重新定义. 
     	  单继承限制: 
   		 在 Java 中, 一个类只能继承一个父类, 但可以实现多个接口. 
   	  继承层次: 
   		 子类可以继续作为其他类的父类, 形成继承链. 
   	  super 关键字: 
   	 	 用于调用父类的构造方法或父类的被重写方法. 
   抽象类的特性: 
         定义: 
   		抽象类是使用 abstract 修饰符声明的类, 它可以包含抽象方法(没有实现的方法). 
   	  不能直接实例化: 
   		只能通过继承来实现抽象类, 子类必须实现抽象方法, 除非子类本身也是抽象类. 
   	  可以包含具体方法: 
   		抽象类不仅可以定义抽象方法, 还可以包含已实现的方法. 
   	  适用于模板设计: 
   		通常用作模板, 定义子类的公共行为, 同时规定子类必须实现的特定方法. 
   抽象方法的特性: 
          定义: 
   		抽象方法是没有方法体的方法,abstract 修饰. 
   	   必须在抽象类中定义: 
   		抽象方法不能单独存在, 必须在抽象类中声明. 
          子类必须实现: 
   		子类需要重写所有的抽象方法, 除非子类本身是抽象类. 
  1. 接口的定义, 类实现接口
   定义接口: 
   public interface FUN {
       // 抽象方法
       void f1();
       // 默认方法
       default void f2() {
           System.out.println("f2");
       }
   }
   类实现接口: 
       public class LM implements FUN { // 使用 implements 关键字来指定接口
       public void f1() {
           System.out.println("f1"); // 实现接口 f1
       }
   
       public void f2() {
           System.out.println("rewrite f2"); // 重写接口 f2
       }
   }
  1. FlowLayout, BorderLayout, JPanel默认布局是Flowlayout, JDialog内容窗格 (content pane) 默认使用的是 BorderLayout, JFrame 的内容窗格(content pane) 默认使用的是 Borderlayout 布局管理器
   题目中就有'答案', 已加粗并斜体处理. 
  1. FileOputStream构造方法
   FileOutputStream(String name) 	// 使用文件名(字符串路径)创建文件输出流. 文件存在时覆盖, 不存在时新建. 
   FileOutputStream(String name, boolean append)	// 使用文件名创建文件输出流, append 指定是否以追加模式写入. 
   FileOutputStream(File file)	// 使用 File 对象创建文件输出流. 文件存在时覆盖, 不存在时新建. 
   FileOutputStream(File file, boolean append)	// 使用 File 对象创建文件输出流, append 指定是否以追加模式写入. 
   FileOutputStream(FileDescriptor fdObj)	// 使用系统中已有的文件描述符创建文件输出流. 
   // String name 为文件路径, 可以是绝对路径或相对路径. 
   // File file File 为类型的对象, 表示目标文件. 
   // boolean append 其为 true 时, 文件写入模式为追加; 为 false 时, 覆盖文件内容. 
   // FileDescriptor fdObj 表示已打开文件的文件描述符(系统资源, 通常很少直接使用). 
  1. 线程基本概念, 构造线程, 线程start方法, run方法, 什么是同步方法, 线程默认优先级别
   线程基本概念: 
   线程是程序执行的基本单位. 每个线程是一个独立的执行路径, 多个线程可以并发运行, 提升程序的响应性和性能. 
   构造线程: 
   class MyThread extends Thread { // 构造线程
       public void run() { // 在run类构造方法
           System.out.println("Thread is running.");
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           Thread thread = new MyThread(); // 创建线程对象
           thread.start();                // start() 被调用, 启动新线程
           thread.run();  // run() 被调用, 不启动新线程, 在当前线程中执行
       }
   }
   start 方法: 
       用于启动线程, 如上. 
   run 方法: 
       包含线程执行的具体代码, 如上. 如果直接调用 run() 方法, 而不是 start() 方法, 代码会在当前线程中执行, 而不会启动新线程. 
   同步方法: 
       同步方法是使用 synchronized 关键字修饰的方法, 确保同一时间只有一个线程可以访问该方法, 从而避免多线程访问共享资源时产生数据不一致的问题. 
   线程默认优先级别: 
       默认优先级: 5. 
   // 优先级范围: 1(最低)到 10(最高). 
   //可以使用 Thread 类的 setPriority() 和 getPriority() 方法. 设置和获取优先级
    
  1. 配置java环境变量, java源程序名, 编译后生成? java中的注释
   // 配置 Java 环境变量的目的是为了在命令行中可以直接使用 javac 和 java 命令. 
   配置java环境变量: 
       右键"此电脑" -> "属性" -> "高级系统设置" -> "环境变量". 
       设置 JAVA_HOME=C:\Program Files\Java\jdk-<version> 为安装路径. 
       Path 中添加 %JAVA_HOME%\bin. 
   java源程序名: 
        Java 源程序文件的扩展名为 .java. 如源文件中定义了 public class 类名, 文件名需定义为 类名.java. // 如 public class Main.  Main.java
    编译后生成的文件: 
         使用 javac 命令编译 Java 源文件后生成 .class 文件. .class 文件为字节码文件, 供 Java 虚拟机(JVM)运行, 其以源文件中包含的类名作为字节码文件名称.. 
    java中的注释: 
          注释是用来向代码中添加说明或备注的文本, 其不会被编译器编入. 注释对于提高代码的可读性和维护性非常重要, 尤其是对于大型项目或团队项目. Java支持三种类型的注释: 
         单行注释: 
           // 原
           // 神
          多行注释: 
           /* 原
           *  神
           *  启
           *  动
           */ 
          文档注释: 
           /**
           * 原
           * @param a 第一个参数 例如 原
           * @param b 第二个参数 例如 神
           * @return 返回值 例如 原 + 神 + 启 + 动
           */
  1. 数组的length属性, java中所有类的父类, java中默认导入的包
   数组的length属性: 
       数组是一个对象, 其 length 属性用于获取数组的大小(元素的个数). //其类型为int
   数组的length属性: 
       所有类的父类是 java.lang.Object. 
   Java 中默认导入的包
       默认导入 java.lang, 无需显式导入. 
  1. super, static, final关键字
   super: 
       用于访问父类的构造方法, 成员变量, 方法. 
   static: 
       用于修饰类的成员, 表示该成员属于类本身, 而非实例, 可用于修饰变量, 方法, 代码块, 嵌套类. 
   final: 
       表示不可更改, 类不能被继承, 方法不能被重写, 变量只能赋值一次成为常量, 引用变量指向的对象不可更改. 
  1. java中修饰符private, protected, public
   private: 
       其为私有访问权限, 仅允许在同一个类中访问. 
   protected: 
       其为受保护的的访问权限, 可以在同一个包中访问, 也可被其他包中的子类访问.  解释 -> // 即使子类位于不同的包中, 它也可以访问父类中声明为 protected 的成员变量和方法. 这是继承的一个重要特性, 允许子类重用和扩展父类的功能. 
   public: 
       其为公共访问权限, 可以在任何地方访问. 
  1. 异常类的父类, throws 和throw的用法, 异常步骤的语句块
   异常类的父类: 
       Java 中所有异常类的父类为 java.lang.Throwable. 
   throwsthrow 的用法: 
       throw 为手动抛出异常, 方法体内使用, 一次只能抛出一个具体的异常对象. 
       throws 为声明方法可能抛出的异常, 方法签名中使用, 可以声明多个异常, 用逗号分隔. 
       throw 用法: 
           public class Main {
               public static void main(String[] args) {
                 try {
                      checkAge(15); //调用checkAge
                  } catch (Exception e) {
                       System.out.println(e.getMessage()); // 捕获异常
                   }
               }
               // checkAge 方法
               public static void checkAge(int age) throws Exception {
                   if (age < 18) {
                    throw new Exception("触发异常"); // throw 触发异常
                   }
               }
           }
       throws 用法: 
           import java.io.*; //导入所需包
           public class Main {
                 try {
                      readFile("test.txt"); //调用readFile
                  } catch (Exception e) {
                       System.out.println(e.getMessage()); // 捕获异常
                   }
               }
            public static void readFile(String fileName) throws IOException {
                   FileReader fileReader = new FileReader(fileName); //获取文件流同时可能 触发 IOException IO异常, 请注意 throws IOException 声明要要触发的异常
               }
           }
   异常步骤的语句块: 
       Java 中异常处理使用 try-catch-finally, 以及可选的 throws 声明. 
           try {
             // 可能产生异常的代码
              int result = 10 / 0; // 如 除 0 异常
           } catch (ExceptionType1 e1) {
              // 捕获并处理 ExceptionType1 类型的异常 以此类推
           } catch (ExceptionType2 e2) {
              // 捕获并处理 ExceptionType2 类型的异常 以此类推
           } catch (ArithmeticException e){
       //捕获除 0 异常
               System.out.println("异常消息:  " + e.getMessage());
           } finally {
              // 必须执行的代码块(可选) 无论是否发生异常其永远会被执行
           }
  1. 方法重载和重写
   方法重载: 
   public class FUN {
       // 方法重载
       public int add(int a, int b) {
           return a + b;
       }
       // 方法重载
       public double add(double a, double b) {
           return a + b;
       }
       // 方法重载
       public int add(int a, int b, int c) {
           return a + b + c;
       }
   
       public static void main(String[] args) {
           FUN fun = new FUN();
           System.out.println(fun.add(10, 20));          // 调用第一个 add 方法
           System.out.println(fun.add(10.5, 20.5));      // 调用第二个 add 方法
           System.out.println(fun.add(10, 20, 30));      // 调用第三个 add 方法
       }
   }
   方法重写: 
       // 父类 A
       class A {
           // 方法 A
              public void a() {
                  // 输出 A
                  System.out.println("A");
              }
       }
       // 子类 B 继承 父类 A并重写 方法 A 输出 B
        class B extends A {
            // 方法 B
          public void a() {
              // 输出 B
              System.out.println("B");
          }
   }
   
       public class Main {
          public static void main(String[] args) {
              A obj = new B(); // 父类对象 A 类型 使用子类 B 创建对象
              obj.a(); // 调用的是子类 B 的 a 方法
          }
       }
   
 **区别**

| **特性**         | **方法重载(Overloading)**              | **方法重写(Overriding)**                                   |
| ---------------- | ---------------------------------------- | ------------------------------------------------------------ |
| **定义位置**     | 同一个类中                               | x`子类对父类的方法进行重写                                   |
| **参数列表**     | 必须不同(类型, 数量或顺序)             | 必须与父类方法完全相同                                       |
| **返回值类型**   | 可以相同或不同, 但不能通过返回值区分重载 | 必须与父类方法相同, 或者是父类返回类型的子类型(协变返回类型) |
| **访问修饰符**   | 无严格要求                               | 子类权限不能低于父类方法                                     |
| **绑定时间**     | 编译时绑定(静态绑定)                   | 运行时绑定(动态绑定)                                       |
| **多态性**       | 不涉及多态                               | 体现运行时多态                                               |
| **使用注解**     | 不需要 `@Override`                       | 建议使用 `@Override` 注解以明确重写                          |
| **典型应用场景** | 提供多个功能相似的实现                   | 修改父类方法以提供子类的具体实现                             |
  1. 抽象类与接口
   抽象类: 
       // 参看以下示例
     定义: 
           抽象类是使用 abstract 修饰符声明的类, 它可以包含抽象方法(没有实现的方法). 
         不能直接实例化: 
           只能通过继承来实现抽象类, 子类必须实现抽象方法, 除非子类本身也是抽象类. 
         可以包含具体方法: 
           抽象类不仅可以定义抽象方法, 还可以包含已实现的方法. 
         适用于模板设计: 
           通常用作模板, 定义子类的公共行为, 同时规定子类必须实现的特定方法. 
            abstract class A {
            // 抽象方法: 没有方法体, 子类必须实现
            public abstract void sl();
             // 非抽象方法: 可以直接被子类继承
            public void sb() {
                System.out.println("sb");
             }
           }
      抽象方法: 
          // 定义可无视
          定义: 
           抽象方法是没有方法体的方法,abstract 修饰. 
          必须在抽象类中定义: 
           抽象方法不能单独存在, 必须在抽象类中声明. 
          子类必须实现: 
           子类需要重写所有的抽象方法, 除非子类本身是抽象类. 
           // 定义抽象类
           abstract class A {
              public abstract void sl(); // 抽象方法
           }
           // 子类实现抽象类
           class B extends A {
             public void sl() {
                 System.out.println("sl");
             }
           }
           // 测试类
           public class Main {
             public static void main(String[] args) {
                A a = new B();
                a.sl(); // 输出: sl
             }
       }
   接口; 
      定义接口: 
      public interface FUN {
          // 抽象方法
          void f1();
          // 默认方法
          default void f2() {
               System.out.println("f2");
          }
      }
      实现接口: 
        
          public class LM implements FUN { // 使用 implements 关键字来指定接口
          public void f1() {
              System.out.println("f1"); // 实现接口 f1
          }
    
          public void f2() {
              System.out.println("rewrite f2"); // 重写接口 f2
          }
      }
    
    
        public class Main { // 伪代码
        public static void main(String[] args) {
    
      构造对象: // flag
        FUN fun1  = new LM(); // 实例化对象
    
      调用方法: // flag
        fun1.f1(); // 调用 f1 方法
        fun.f2(); // 调用 f2 方法
        }
    }	
  1. ActionEvent事件监听, 实现ActionListener接口中的什么方法, 读文件FilelnputStream, , BufferedReader两者都可以, 按钮事件监听, JTextField, JButton, JTextArea
   import javax.swing.*;
   import java.awt.event.*;
   import java.io.*;
   
   public class Main {
       public static void main(String[] args) {
           // 创建按钮
           JTextField text = new JTextField("deflault");
           JButton button = new JButton("读取文件");
           JFrame frame = new JFrame("文件读取示例");
           frame.setSize(300, 200);
           frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   
           // 添加按钮事件监听 JButton
           button.addActionListener(new ActionListener() {
               public void actionPerformed(ActionEvent e) {
                   // 在这里实现文件读取
                   try (BufferedReader br = new BufferedReader(new FileReader(text.getText())) {
                       String line;
                       System.out.println("文件内容: ");
                       while ((line = br.readLine()) != null) {
                           System.out.println(line);
                       }
                   } catch (IOException ex) {
                       ex.printStackTrace();
                   }
               }
           });
           frame.add(text);
           frame.add(button);
           frame.setVisible(true);
       }
   }
   
   
  1. 定义接口, 实现接口, 构造对象, 调用方法

       定义接口: 
       public interface FUN {
           // 抽象方法
           void f1();
           // 默认方法
           default void f2() {
                System.out.println("f2");
           }
       }
       实现接口: 
    
           public class LM implements FUN { // 使用 implements 关键字来指定接口
           public void f1() {
               System.out.println("f1"); // 实现接口 f1
           }
    
           public void f2() {
               System.out.println("rewrite f2"); // 重写接口 f2
           }
       }
    
    
     public class Main { // 伪代码
         public static void main(String[] args) {
    
     构造对象: // flag
         FUN fun1  = new LM(); // 实例化对象
    
     调用方法: // flag
         fun1.f1(); // 调用 f1 方法
        fun.f2(); // 调用 f2 方法
         }
     }
    
  2. java源程序的构成, java源程序文件命名, public类, main方法的参数

   java源程序构成:  
       java源程序的构成java源程序由 包声明(可选), 包导入(可选), 类定义, 方法定义所构成. 
   java源程序文件命名:  
       如果一个类为public类, 则文件名必须与该类名相同且区分大小写. 
   public类:  
       一个源文件中仅允许存在一个public类. 如果存在public类, 则该类为程序的主要入口或关键部分. 如存在多个类其余类(默认为default级别)不能标记为public类. 
   mian方法的参数:  
       String[] args 接收命令行参数, 其为字符串数组, 存储运行程序时传递的参数. 
  1. java中标识符命名规则, java中基本数据类型, 特别注意float类型
   java中标识符命名规则: 
       标识符只能由 字母(A-Z, a-z), 数字(0-9), 下划线(_)美元符号($)组成, 不能以数字开头. 区分大小写, 无法使用关键字命名. 不能出现空格
   java中基本数据类型: 
       整数类型, 浮点类型, 字符类型,  布尔类型
       byte short int long,  float double,  char, boolean
   特别注意float类型: 
       默认小数是 double 类型, 定义 float 时需加 f 后缀; float 精度低于 double. 
   	
  1. 掌握基本算术运算符+, -, x,1, %, ++, –
   public Main {
       public void static main(String[] args){
           int add = 1 + 1; //结果为 2 加法运算
           int less = 1 - 1; // 结果为 0 减法运算
           int cf = 1 * 1; // 结果为 1 乘法运算
           int div = 1 / 1; // 结果为 1 除法运算
           int qy = 1 % 1 // 结果为 0 取余运算
           int test = 1; //创建变量并赋值
           ++test //结果为 2 , 自增运算, 先计算后赋值 
           test++ //结果为 2 , 自增运算, 先赋值后计算
           test = 1 // 重新赋值
           --test //结果为 0 , 自减运算, 先计算后赋值
           test-- //结果为 0 , 自减运算, 先赋值后计算
           // 自增运算常用于循环计算
       }
   }
  1. java中while循环, 与do while循环的区别
   while循环:  
   	在执行循环体之前, 先判断条件, 如为false则循环体一次都不会执行. 
   do while循环:  
   	先执行一次循环体, 再判断条件是否成立, 即条件为false, 循环体至少会执行一次. 
  1. 构造的定义, 构造的重载
   // example
   class Example {
       int tmp;
       Example(){
           this.tmp = 1;
           System.out.printf("无参构造");
       }
       Example(int tmp){
           this.tmp = tmp;
           System.out.prinft("有参构造");
       }
   }
   Example ex1 = new Example(); // 触发无参构造
   Example ex2 = new Example(1); // 触发有参构造即
  1. final, static, abstract关键字, 抽象类, 抽象方法
   final: 
       表示不可更改, 类不能被继承, 方法不能被重写, 变量只能赋值一次成为常量, 引用变量指向的对象不可更改. 
   static: 
       用于修饰类的成员, 表示该成员属于类本身, 而非实例, 可用于修饰变量, 方法, 代码块, 嵌套类. 
   abstract: 
   	用于修饰类与方法, 表示该类属于抽象类/方法, 抽象类无法被实例化(无法通过 new 对象创建关键字), 抽象方法与类需重写
   抽象类: 
         定义: 
   		抽象类是使用 abstract 修饰符声明的类, 它可以包含抽象方法(没有实现的方法). 
   	  不能直接实例化: 
   		只能通过继承来实现抽象类, 子类必须实现抽象方法, 除非子类本身也是抽象类. 
   	  可以包含具体方法: 
   		抽象类不仅可以定义抽象方法, 还可以包含已实现的方法. 
   	  适用于模板设计: 
   		通常用作模板, 定义子类的公共行为, 同时规定子类必须实现的特定方法. 
      		 abstract class A {
      		 // 抽象方法: 没有方法体, 子类必须实现
      		 public abstract void sl();
     		  // 非抽象方法: 可以直接被子类继承
      		 public void sb() {
      		     System.out.println("sb");
     		  }
   		}
   抽象方法: 
          定义: 
   		抽象方法是没有方法体的方法,abstract 修饰. 
   	   必须在抽象类中定义: 
   		抽象方法不能单独存在, 必须在抽象类中声明. 
          子类必须实现: 
   		子类需要重写所有的抽象方法, 除非子类本身是抽象类. 
           // 定义抽象类
   		abstract class A {
    		   public abstract void sl(); // 抽象方法
   		}
   		// 子类实现抽象类
   		class B extends A {
     		  public void sl() {
     		      System.out.println("sl");
     		  }
   		}
   		// 测试类
   		public class Main {
     		  public static void main(String[] args) {
      		     A a = new B();
       		 a.sl(); // 输出: sl
     		  }
   	}
   
  1. instanceof运算符的使用, 对象的上转型的理解.
   instanceof 运算符用于判断一个对象是否是某个类的实例, 或者是某个类的子类的实例. 其为 Java 中的一个 二元运算符, 返回值是布尔类型 (truefalse). 
   示例: 
   class A { }
   class B extends A { }
   class C extends A { }
   public class Main {
       public static void main(String[] args) {
           A a = new B();
   
           // 判断类型
           System.out.println(a instanceof A); // true
           System.out.println(a instanceof B);    // true
           System.out.println(a instanceof C);    // false
   
           // 安全转换
           if (a instanceof B) {
               B b = (B) a; // 安全的向下转型
           }
       }
   }
   对象的上转型的理解: 
       上转型 是指将子类对象转换为父类类型. 上转型是 自动进行 的, 不需要显式的类型转换. 上转型后, 子类对象被当作父类对象对待, 只能访问父类中定义的成员(但方法调用支持多态). 
   class A {
       void sl() {
           System.out.println("sl1");
       }
   }
   
   class B extends A {
       void sv() {
           System.out.println("sv");
       }
   
       void sl() {
           System.out.println("sl2");
       }
   }
   
   public class MaIN {
       public static void main(String[] args) {
           // 子类对象
           B b = new B();
           // 上转型
           A a = b; // 自动上转型
           // 调用方法
           a.sl(); // 调用子类的 sl 方法(多态)
           a.sv(); // 错误: 不能调用子类特有的方法
           // 如果需要调用子类方法, 可以向下转型
           if (a instanceof B) {
               B bc = (B) a; // 向下转型
               bc.sv(); // 调用子类的特有方法
           }
       }
   }
   
  1. 接口的定义, 接口中方法以及数据成员的默认修饰符
   public interface InterDefine {
       // 常量
       int CONSTANT = 10; // 常量也就是数据成员 默认是 public static final 修饰符, 只能使用 public, 无法修改为 private 或 protected
       // 抽象方法
       void myMethod();  // 方法默认是 public abstract 修饰符, 不能修改为 private, protected, 不可赋值
   }
   // 接口中的方法默认是 public abstract 的, 表示这些方法是公开的, 并且必须被实现类实现. 
  1. Float, Integer, Double中parse方法的使用
   public class Main {
       public static void main(String[] args) {
           String str = "12.34";
           //将字符串转换为 Float类型
           float number = Float.parseFloat(str);
           //将字符串转换为 Integer类型
           int number = Integer.parseInt(str);
           //将字符串转换为 Duble类型
           double number = Double.parseDouble(str);
       }
   }
  1. 构造窗体, 窗体默认是否可见, 如何修改窗体标题, 设置可见
   import javax.swing.JFrame;
   
   public class Main {
       public static void main(String[] args) {
           // 创建一个 JFrame 对象
           JFrame frame = new JFrame();
   
           // 设置窗体的标题
           frame.setTitle("标题");
   
           // 设置窗体大小
           frame.setSize(400, 300);
   
           // 设置关闭操作(点击关闭按钮时退出程序)
           frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   
           // 设置窗体是否可见
           frame.setVisible(true);
       }
   }
   
  1. 线程基本概念, 构造线程, 线程start方法, run方法, 什么是同步方法, 线程默认优先级别
   线程基本概念: 
   线程是程序执行的基本单位. 每个线程是一个独立的执行路径, 多个线程可以并发运行, 提升程序的响应性和性能. 
   构造线程: 
   class MyThread extends Thread { // 构造线程
       public void run() { // 在run类构造方法
           System.out.println("Thread is running.");
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           Thread thread = new MyThread(); // 创建线程对象
           thread.start();                // start() 被调用, 启动新线程
           thread.run();  // run() 被调用, 不启动新线程, 在当前线程中执行
       }
   }
   start 方法: 
       用于启动线程, 如上. 
   run 方法: 
       包含线程执行的具体代码, 如上. 如果直接调用 run() 方法, 而不是 start() 方法, 代码会在当前线程中执行, 而不会启动新线程. 
   同步方法: 
       同步方法是使用 synchronized 关键字修饰的方法, 确保同一时间只有一个线程可以访问该方法, 从而避免多线程访问共享资源时产生数据不一致的问题. 
   线程默认优先级别: 
       默认优先级: 5. 
   // 优先级范围: 1(最低)到 10(最高). 
   //可以使用 Thread 类的 setPriority() 和 getPriority() 方法. 设置和获取优先级
  1. Flowlayout, Borderlayout, JPanel默认布局是Flowlayout, JDialog内容窗格 (content pane) 默认使用的布局是 BorderLayout, JFrame 的内容窗格(content pane) 默认使用的是 BorderLayout 布局管理器
   题目中就有'答案', 已加粗并斜体处理. 
  1. java, javac命令的使用
   javac: javac为Java编译器, 用于将 .java文件编译为 .class字节码文件. javac 源程序名称.java 如 javac Main.java
   java: java命令用于启动jvm虚拟机并执行已编译好的.class字节码文件. java 类名称 如 java Main
  1. java中的注释
   注释是用来向代码中添加说明或备注的文本, 其不会被编译器编入. 注释对于提高代码的可读性和维护性非常重要, 尤其是对于大型项目或团队项目. Java支持三种类型的注释: 
   单行注释: 
       // 原
       // 神
    多行注释: 
       /* 原
       *  神
       *  启
       *  动
       */ 
      文档注释: 
       /**
    	* 原
    	* @param a 第一个参数 例如 原
    	* @param b 第二个参数 例如 神
    	* @return 返回值 例如 原 + 神 + 启 + 动
    */
  1. 数组的length属性, java中所有类的父类, java中默认导入的包
   数组的length属性: 
       数组是一个对象, 其 length 属性用于获取数组的大小(元素的个数). //其类型为int
   数组的length属性: 
       所有类的父类是 java.lang.Object. 
   Java 中默认导入的包
       默认导入 java.lang, 无需显式导入. 
  1. java中修饰符private, protected, public
   private: 
       其为私有访问权限, 仅允许在同一个类中访问. 
   protected: 
       其为受保护的的访问权限, 可以在同一个包中访问, 也可被其他包中的子类访问.  解释 -> // 即使子类位于不同的包中, 它也可以访问父类中声明为 protected 的成员变量和方法. 这是继承的一个重要特性, 允许子类重用和扩展父类的功能. 
   public: 
       其为公共访问权限, 可以在任何地方访问. 
  1. 菜单的组成
   菜单由菜单(JMenu), 菜单栏(JMenuBar), 菜单项(JMenuItem)基本三项组成
   代码如下: 
   import javax.swing.*;
   import java.awt.event.ActionEvent;
   import java.awt.event.ActionListener;
   
   public class Main {
       public static void main(String[] args) {
           // 创建窗体
           JFrame frame = new JFrame("菜单示例");
           frame.setSize(400, 300);
           frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   
           // 创建菜单栏
           JMenuBar menuBar = new JMenuBar();
   
           // 创建菜单
           JMenu fileMenu = new JMenu("文件");
           JMenu editMenu = new JMenu("编辑");
           JMenu viewMenu = new JMenu("视图");
   
           // 创建菜单项
           JMenuItem openItem = new JMenuItem("打开");
           JMenuItem saveItem = new JMenuItem("保存");
           JMenuItem exitItem = new JMenuItem("退出");
   
           // 为菜单项添加事件监听器
           exitItem.addActionListener(new ActionListener() {
               public void actionPerformed(ActionEvent e) {
                   System.exit(0); // 退出程序
               }
           });
   
           // 将菜单项添加到菜单
           fileMenu.add(openItem);
           fileMenu.add(saveItem);
           fileMenu.addSeparator(); // 添加分隔线
           fileMenu.add(exitItem);
   
           // 添加菜单到菜单栏
           menuBar.add(fileMenu);
           menuBar.add(editMenu);
           menuBar.add(viewMenu);
   
           // 设置菜单栏到窗体
           frame.setJMenuBar(menuBar);
   
           // 设置窗体可见
           frame.setVisible(true);
       }
   }
   
  1. 断言的作用以及如何使用断言
   断言的作用:  断言为用于在代码运行时验证某些条件是否成立. 用于检测程序中的逻辑错误
   使用断言:  启动断言 java -ea AssertionExample // 断言默认关闭
   public class AssertionExample {
       public static void main(String[] args) {
           int value = 10;
           assert value > 0 : "值应大于0"; //此处为断言, 用于判断值是否大于0, 大于0则正常执行不触发断言 其实就是一个三目运算
           String str = "sblls";
           assert str != "sbdl": "值不应为sbdl"; // 此处为断言 用于判断字符串是否为 sbdl 如不为 sbdl 再执行下一行 其实就是一个三目运算
           System.out.println("Hello World");
       }
   }
  1. 循环语句中break 与continue的区别.
   break:  跳出当前循环并中止整个循环. 
   
   continue:  跳过本轮循环剩余代码, 并进入下一轮循环. 
  1. 异常处理模块. try….
   在 Java 中, 异常处理模块用于捕获和处理程序运行时发生的错误, 防止程序因异常而终止. 通过 try-catch-finally 结构, 开发者可以优雅地处理异常, 并保证程序的正常运行. 
   example:
   try {
       // 可能产生异常的代码
       int result = 10 / 0; // 如 除 0 异常
   } catch (ExceptionType1 e1) {
       // 捕获并处理 ExceptionType1 类型的异常 以此类推
   } catch (ExceptionType2 e2) {
       // 捕获并处理 ExceptionType2 类型的异常 以此类推
   } catch (ArithmeticException e){
       //捕获除 0 异常
       System.out.println("异常消息:  " + e.getMessage());
   } finally {
       // 必须执行的代码块(可选) 无论是否发生异常其永远会被执行
   }
   
  1. 什么是多态, 什么是面向对象程序设计的开闭原则,
   多态:  
       多态为面向对象编程的重要特性, 它允许同一个接口或方法在不同的类中具有不同的实现形式. 简单来说就是多态意味着同一操作在不同对象上可以表现出不同行为. 
   开闭原则:  
       开闭原则是面向对象设计的六大原则之一, 旨在确保软件具有良好的扩展性和稳定性. 其定义为一个实体(如类, 模块, 函数等)应对扩展开放, 意味着可以通过添加新功能来扩展模块的行为. 对修改关闭, 意味着在扩展功能时, 不应修改已有的代码. 
  1. JComboBox触发temEvent, 事件处理方法void itemStateChanged(ltemEvent e)按钮事件监听JTextField, JButton, JTextArea, JComboBox
   JComboBox触发temEvent, 事件处理方法void itemStateChanged(ltemEvent e): 
   import javax.swing.*;
   import java.awt.event.*;
   
   public class JComboBoxExample {
       public static void main(String[] args) {
           // 创建 JFrame
           JFrame frame = new JFrame("JComboBox Example");
           frame.setSize(400, 200);
           frame.setLayout(null);
   
           // 创建 JComboBox
           String[] items = {"Option 1", "Option 2", "Option 3"};
           JComboBox<String> comboBox = new JComboBox<>(items);
           comboBox.setBounds(50, 50, 150, 30);
   
           // 添加 ItemListener
           // 当 JComboBox 的选项发生更改时, 会触发 ItemEvent, 通过 ItemListener 进行处理. 
           comboBox.addItemListener(new ItemListener() {
               public void itemStateChanged(ItemEvent e) {
                   if (e.getStateChange() == ItemEvent.SELECTED) {
                       System.out.println("Selected: " + e.getItem());
                   }
               }
           });
   
           // 添加到 JFrame
           frame.add(comboBox);
           frame.setVisible(true);
       }
   }
   按钮事件监听JTextField, JButton, JTextArea, JComboBox:
   import javax.swing.*;
   import java.awt.event.*;
   import java.io.*;
   
   public class Main {
       public static void main(String[] args) {
           // 创建按钮
           JTextField text = new JTextField("deflault");
           JButton button = new JButton("读取文件");
           JFrame frame = new JFrame("文件读取示例");
           frame.setSize(300, 200);
           frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   
           // 添加按钮事件监听 JButton
           button.addActionListener(new ActionListener() {
               public void actionPerformed(ActionEvent e) {
                  System.out.println(text.getText());
           });
           frame.add(text);
           frame.add(button);
           frame.setVisible(true);
       }
   }
   
  1. 类的定义(数据成员, 成员方法), 对象的构造, 方法的调用.
   类的定义: 
       class A {
           // 数据成员
           private int a;
           // 成员方法
           public void seta(int a){
               this.a = a;
           }
       }
   public class Main{
       public static void mian(String[] args){
   对象的构造: 
       A a = new A(); // 构造对象
   方法调用: 
       a.seta(1); // 调用方法
        }
    }
路漫漫其修远兮,吾将上下而求索。
Built with Hugo
主题 StackJimmy 设计