目录

一.递归结构

二.异常机制

三.断点

四.泛型

4.1 泛型基本概念和定义

4.2 泛型类

4.3 泛型接口

4.4 泛型方法

4.4.1 非静态方法

4.4.2 静态方法

import java.io.File;

public class test {
    public static void main(String[] args) {
        File f=new File("D:/Program Files");
        printFile(f,0);
    }
    static void printFile(File f,int l){
        for(int i=0;i 
二.异常机制 
异常处理就是指程序在出现问题时依然可以正确的执行完。
 
1.抛出异常：在执行一个方法时，如果发生异常，则这个方法生成代表该异常的一个对象，停止当前执行路径，并把异常对象交给JRE。
 
2.捕获异常：JRE得到该异常后，寻找相应的代码来处理该异常。
 
try（）catch（）处理：
 
public class test {
    public static void main(String[] args) {
        try {
            FileReader re=new FileReader("d:/a.txt");
            char c=(char)re.read();
            char c1=(char)re.read();
            System.out.println(c+c1);    
        }catch (Exception a){
            a.printStackTrace();
        }

    }
}
 
throw处理：
 
public class test {
    public static void main(String[] args) throws Exception {
        FileReader re=new FileReader("d:/a.txt");
        char c1=(char) re.read();
        char c2=(char) re.read();
        System.out.println(c1+c2);
    }
}
 
三.断点 
1.设置断点：
 
（1）在行号后面单击即可增加断点。
 
（2）在断点上单击即可取消断点。
 
 
四.泛型 
4.1 泛型基本概念和定义 
数据类型参数化，把数据类型当作参数一样传递，优点是提高代码的可读性和安全性。
 
泛型字符可以是任意标识符，一般采用E,T,K,V,N...;
 
 
4.2 泛型类 
把泛型定义在类上，使用该类的时候，把泛型明确下来。
 
public class fanxing {
    private T t;

    public void setT(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }
}
 
public class test {
    public static void main(String[] args)  {
        //使用该类时，若没有表明该泛型的类型，则默认为Object类型
     fanxing t1=new fanxing();
     t1.setT("a");
        System.out.println(t1.getT());
    }
}
 
4.3 泛型接口 
public class test {
    public static void main(String[] args)  {
        Igeneric t1=new fanxing() ;//定义接口类型
            String n1= t1.getname("doudou");
        System.out.println(n1);
        fanxing t2=new fanxing();
        String n2=t2.getname("dou");
        System.out.println(n2);
    }
}
 
4.4 泛型方法 
  泛型类中所定义的泛型，在方法中也可以使用。但是，我们经常需要仅仅在某一个方法上使用泛型，这时候可以使用泛型方法。
 
   泛型方法是指将方法的参数类型定义成泛型，以便在调用时接受不同类型的参数。
 
    调用泛型方法时，不需要像泛型类告诉编译器是什么类型，编译器可以自动推断出来。
 
4.4.1 非静态方法 
语法结构：
 
 
public <泛型表示符号>void getName(泛型表示符号  name){
 
}
 
 
public <泛型表示符号>泛型表示符号 getName（泛型表示符号 name）{
 
}
 
 
 
 
 
 
public class text {
    public void setName(T name){
        System.out.println(name);
    }
    public  T getName(T name){
        return name;
    }
}
 
public class text1 {
    public static void main(String[] args) {
        text t=new text();
        t.setName(12);
        t.getName("das");
        text t2=new text();
        String name=t2.getName("dou");
        Integer n2=t2.getName(12);
        System.out.println(name);
        System.out.println(n2);
    }
}
 
 
4.4.2 静态方法 
静态方法无法访问类上的泛型，如果静态方法操作的引用数据类型不确定，必须将泛型定义在方法上。
 
 
public static <泛型表示符号>void getName(泛型表示符号 name){
 
}
 
 
public static<泛型表示符号>泛型表示符号 getName（泛型表示符号 name）{
 
}
 
 
 
 
 
 
public class text {
    private T name;
    public static  void setName (T name){
        System.out.println(name);
    }
    public static T getName(T name){
        return name;
    }



}
 
public class text1 {
    //静态方法可以不需要创建对象直接调用
    public static void main(String[] args) {
        text.setName(12);
        text.getName("dd");
        System.out.println(text.getName("doudou"));
    }
}