java易错题型（复习必看）

java易错题型：

---

1. 下列符号中，哪个用于分隔throws关键字抛出的多个异常 逗号，

2. Java中用来声明一个方法可能抛出某种异常的关键字是throw

3. 对于catch子句的排列，下列哪种是正确的：子类异常在先，父类异常在后（先子类后父类）捕获到父类便不会在捕捉子类

4. throws关键字用于对外声明方法可能发生的异常，这样调用者在调用方法时，可以明确知道该方法有异常，并进行相关处理 对

5. this关键字可以用来调用构造方法，不能在普通方法中使用，只能写在构造方法中，而且必须写在第一条语句

6. 静态变量用于共享数据，例如班级，每个人的名字可以不同，但是班级一定相同，这是后就可以使用static来输入班级：static string classname;然后就可以在创建对象前student.classname=“三年级”,这时候当创建其他对象就不需要另外赋值

7. 子类继承父类，要想在子类中修改父类变量，需要在子类的构造方法中修改，例如，不过调用父类的方法，可以在任何方法中调用，但是不能在非方法外调用

   class Fu{
       public int num=20;
   }
   class Zi extends Fu{
       Zi(){
        //无参构造
           super.num=2;
       }
       
   

8. 是的，你完全正确。在Java中，如果一个类（包括接口）被声明为public，那么它必须被定义在与其类名（包括大小写）完全相同的.java文件中。这是Java编程语言的一个基本规则。

   例如，如果你有一个公共接口叫做E，那么它应该被定义在一个叫做E.java的文件中。同样地，如果你有一个公共类叫做MyClass，那么它应该被定义在一个叫做MyClass.java的文件中

9. 一个类继承了接口的抽象方法就必须实现这个接口的所有抽象方法

10. 向上转型是指将子类对象转换为父类类型。向上转型是自动且安全的，因为子类对象本质上也是一种父类对象。向上转型的主要目的是利用多态性，使得父类引用可以指向子类对象。向下转型是指将父类对象转换为子类类型。向下转型是显式的，并且需要进行类型检查，以确保父类引用实际上指向的是子类对象。向下转型如果不正确，会抛出 ClassCastException 异常。

11. 问题：匿名内部类

12. string类属于java.long 包

13. 构造方法的重写与重载：重载是方法名相同参数不同，重写是指子类写了与父类同方法名同参数数量的方法

14. substring截取字符串：一个参数，直接从该参数索引到字符串结束，两个参数：包头不包尾：包含起始下标字符不包含结尾下标字符

15. 抽象方法是没有方法体的方法，包含抽象方法的类必须声明为抽象类，但是抽象类可以不包含任何抽象方法，只需使用abstract关键字修饰即可，另外抽象类也可包含具体方法

16. 构造方法和普通方法的区别：

    1. 构造方法的方法名与类名相同
    2. 构造方法没有返回值类型
    3. 没有return语句

17. 在java中如何处理异常

    1. 使用try{}catch(){}finally{}语句
    2. 在方法名后边使用throws Exception语句

18. byte类型的数据在进行运算的时候会自动提升为int类型，需要加一个byte a=(byte)(b+c)

19. java的IO操作

    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    
    public class starct{
        public static void main(String args[]) throws Exception{
            FileReader reader=new FileReader("abc.txt");
            BufferedReader aa=new BufferedReader(reader);
            FileWriter write=new FileWriter("cba.txt");
            BufferedWriter bb=new BufferedWriter(write);
            String str;
            while((str=aa.readLine())!=null{
                bb.write(str);
                bb.newLine();//生成换行符
            }
            aa.close();
            bb.close();
        }
                  }
    

import javafx.stage.DirectoryChooserBuilder;

import javax.swing.*;
import javax.xml.bind.Unmarshaller;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.PropertyChangeListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public  class  starct extends JFrame{
    JTextArea area;
    JTextField tf;
    public starct(){
        setLayout(new GridLayout(3,1));//设置构造方法直接生成窗体
        JLabel label=new JLabel("姓名");//设置姓名标签
        tf=new JTextField(15);
        JLabel lb1=new JLabel("选课");
        JCheckBox cb1=new JCheckBox("英语");
        JCheckBox cb2=new JCheckBox("数学");
        JCheckBox cb3=new JCheckBox("计算机");
        area=new JTextArea();
        JPanel panel1=new JPanel();
        JPanel panel2=new JPanel();
        panel1.add(label);
        panel1.add(tf);
        panel2.add(lb1);
        panel2.add(cb1);
        panel2.add(cb2);
        panel2.add(cb3);
        add(panel1);
        add(panel2);
        add(area);
        cb1.addActionListener(listener1);
        cb2.addActionListener(listener1);
        cb3.addActionListener(listener1);
        setSize(300,150);
        this.setVisible(true);
    }
    Set<String> hobbies=new HashSet<String>();
    ActionListener listener1=new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            JCheckBox cb=(JCheckBox) e.getSource();
                    if(cb.isSelected()){
                        hobbies.add(cb.getText());
        }else{
                        hobbies.remove(cb.getText());
                    }
                    print();
    }
};
    private void print(){
    area.setText("");
    if(hobbies.size()>0)
        area.append(tf.getText()+"的选课有");
        Iterator<String> it=hobbies.iterator();
        while(it.hasNext()){
            area.append(it.next()+" ");
        }
    }
    public static  void main(String []args){
        new starct();
    }
}

19. arraylist集合的遍历

import java.util.ArrayList;
import  java.util.*;
public class starct{
    public static void main(String[] args) {
        ArrayList st=new ArrayList();
        st.add("shix");
        st.add("hhh");
        Iterator it=st.iterator();
        while(it.hasNext()){
            Object o=it.next();
            System.out.println(o);
        }
    }
}

另一种遍历方法:foreach循环

for(Object o:st){
    System.out.println(o);
}

foreach循环的局限性：不能修改数组中的元素

20. hashmap的遍历；

import jdk.nashorn.internal.runtime.arrays.IteratorAction;

import java.util.ArrayList;
import  java.util.*;
public class starct{
    public static void main(String[] args) {
        HashMap aa=new HashMap();
        aa.put(1,"shix");
        aa.put(2, "噢噢噢噢、");
        System.out.println(aa.get(2));
        System.out.println(aa.get(1));//根据键获取值
        Set keyset=aa.keySet();//从一个aa映射中获取键的集合keyset
        Iterator st=keyset.iterator();//然后创建一个迭代器来遍历这些键
        while (st.hasNext()){
            Object hh=st.next();//hh获取键
            Object value=aa.get(hh);//value获取该键值的value
            System.out.println(hh+":"+value);
        }
    }
}

21. 两种实现多线程的方式

import jdk.nashorn.internal.codegen.OptimisticTypesPersistence;
import jdk.nashorn.internal.runtime.arrays.IteratorAction;

import java.util.ArrayList;
import  java.util.*;
class Ticket extends Thread{
    private int tickets=100;
    public void run(){
        while(true){
            if(tickets>0){
                Thread th=Thread.currentThread();//获取当前线程
                String th_name=th.getName();//获取当前线程的名字
                System.out.println(th_name+"正在发售"+ tickets--+"票");
            }
        }
    }
}
public class starct{
    public static void main(String[] args) {
       new Ticket().start();
       new Ticket().start();
       new Ticket().start();

    }
}

import jdk.nashorn.internal.codegen.OptimisticTypesPersistence;
import jdk.nashorn.internal.runtime.arrays.IteratorAction;

import java.util.ArrayList;
import  java.util.*;
class Ticket implements Runnable{
    private int tickets=100;
    public void run(){
        while(true){
            if(tickets>0){
                Thread th=Thread.currentThread();//获取当前线程
                String th_name=th.getName();//获取当前线程的名字
                System.out.println(th_name+"正在发售"+ tickets--+"票");
            }
        }
    }
}
public class starct{
    public static void main(String[] args) {
        Ticket tw=new Ticket();
       new Thread(tw,"窗口").start();
       new Thread(tw,"shix");

    }
}

22. 多态，异常
23. 匿名内部类

import jdk.nashorn.internal.codegen.OptimisticTypesPersistence;
import jdk.nashorn.internal.runtime.arrays.IteratorAction;

import java.util.ArrayList;
import  java.util.*;
interface animal{
    void shot();
}
public class starct{
    public static void main(String[] args) {
       String name="笑话";
       animalshot(new animal(){
           public void shot(){
               System.out.println("喵咪爱哦");
           }
       });

    }
    public static void animalshot(animal an){
        an.shot();
    }
}