【JAVA期末复习资源】包含重点知识、踩坑知识，期末复习看这一份就够了

在包里面
src\helloworld> javac -d . helloworld.java   //java的类命令
src\helloworld> java helloworld.helloworld
不在包里面
src> javac hellworld.java
src> java helloworld

abstract class    extends implements null      strictfp     true
assert   const    false   import     package   super        try
boolean  continue final   instanceof private   switch       void
break    default  finally int        protected synchronized volatile
byte     do       float   interface  public    this         while
case     double   for     long       return    throw
catch    else     goto    native     short     throws
char     enum     if      new        static    transient

int i;
System.out.println(i);

int main()
{
    int i = 2;
    switch (i)
    {
        case 1:
            printf("%s\n", "case 1");
        default:
            printf("%s\n", "default");
        case 2:
            printf("%s\n", "case 2");
        case 3:
            printf("%s\n", "case 3");
    }
    return 0;
}

for(int x;a数组)
    System.out.println(x);

import java.util.Scanner//输入的包
                Scanner stdion=new Scanner(System.in)//固定格式，但只要写一个就好了
                int n= stdio.nextInt();//不同的类型对对应不同的stdio.next类型

package test
import java.util.Scanenr
public class JieChengHe{
public static void main(String[] args) 
{Scanner stdio=new Scanner(System.in);
  int n=stdio.nextInt();
  int sum=0;int k=1;
  for(int i=1;i<=n;i++)
    {for(int j=1;j<=i;j=++)
      k*=j;
    }
  sum+=k;
  k=1;
}
  System.out.println("n的阶乘和为"+n);
  }

public class Test
{int i=1,j=1;
    Test()
    ｛i=i+j;
        ｝
    Test(int i)
    {i++;}
}

题目
x=1,y=2;
p.setdate(x,y);
1
void setdate(int a,int b)
{a=10,b=20;}
2
void setdate(Point p)
{p.x=10;
 p.y=20;}
3
void setdate(Point p)
p=new Point();
p.x=10;
p.y=20;
}

int c1,c2;
public apple(int a,int b)
{
    apple.a=1;
    apple.b=2;
}
public apple(int a ,int b,int c)
{
    this.(a, b);
    apple.c=3;
}

public class ok{
int a=0
static b=0;
void  y()
a++;
b++;}
public static void main(String[] args)
{ok ok1=new ok();
 ok ok2=new ok();
ok1.y;
ok1.y;
ok2.y;
System.out.println(ok1.a+" "+ok1.b);
System.out.println(ok2.a+" "+ok2.b);
}

Book book1 = new Book(1);
new Book(2);
new Book(3);

//B类继承A类
public class B extends A {
       //B带参的构造方法
        B(String name) {
            super(name);
            System.out.println("B-->" + name);
         }
        public static void main(String[] args) {
            B b = new B("good");
        }
}
//创建A类
class A {
    //A带参的构造方法
    A(String name) {
        System.out.println("A-->" + name);
    }
}

fulei a = new fulei();
zilei b= (zilei) a;

Z a=new Z();
F b=new F();
F c=a;

public class father
{
    int m=0;
   public void ok()
    {
        System.out.println("father");
    }
}
public class child extends father 
{
    int m=1;
   public void ok()
    {
        System.out.println("child");
    }
    public static void main(String a[])
    {
        father f1=new father()
        f1=new chile();
        f1.ok();
        System.out.println(f1.m);
    }
}
//结果是child   0

int a=0;
    static int b=0;
    public static void main(String[] args) {
   c100 A=new c100();
   c100 B=new c100();
   A.a++;
   B.a++;
   A.b++;
   B.b++;
    System.out.println(A.a);
    System.out.println(B.a);
    System.out.println(A.b);
    System.out.println(B.b);

static int m=0 ;
    void ok()
    {
        static int m=0 ;
    }

public class Hero()
{
    Hero h =new Hero()
    {
        public void attack()
            {System.out.println("杀疯了");}
    }
    h.attack();
}

public class Hero{
    class SomeHero extends Hero(){ 
        void attack()
                {System.out.println("杀疯了")}}
    SomeHero h = new SomeHero(); 
    h.attack();
}

char a[];//定义一个数组
char a[]={'a','b'};//初始化数组
char a[]=new char[3];//定义一个数组对象
a[3]='a';//字符数组对象初始化
String s[]=new String[3];//定义一个字符串对象
s[0]=new String("czj");//字符串数组初始化

int [][]max=new int[2][2];

int [][][]mat=new int [3][][];//三维
mat[0]=new int [2][];//二维
mat[0][0]=new int [2];//一维

String [][]mat={{new String ("Hello"), new String("world")},
               {new String("hello"),new String ("java")}};

String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
String sentence2 = String.format(sentenceFormat, name,kill,title);
System.out.println(sentence2);

char []cs=new char []{'牛','马','人'};
String hero =new String(cs);

String a="好的呢";
StringBuffer b=new StringBuffer(a);

Vector <String> m = new Vector<String>(5,10); 
    初始容量为5，扩容为10

方法1 String[]+new+put
String[] s1={~};
Hashtable<String,Integer> h=new Hashtable<String,Integer>(800,0.77f);
//800为初始容量，0.77f为装填因子，当然这个两个也都可以不要的
for(int i =0;i<s1.length;i++){h.put(s1[i],new Integer(i))};
//方法2

int a[] = {1, 2, 4, 5, 6, 7, 8, 8, 9, 9, 9, 6, 5, 54, 4, 3, 3,};
Arrays.sort(a);

//首先输入字符串，然后转化为字符数组，最后看条件是不是要转化为整数数组
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
String[] p = line.split(" ");
Vector<~> v = new Vector<>();
for (String x : p) {Vector.add(x);}
或者for (String x : p) {Vector.add(Integer.parseInt(x));}
//如果是整数比大小
        Collections.sort(v, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) 
        return o2-o1);
        }});
//如果是字符串比大小
        Collections.sort(v,new Comparator<String>(){
        public int compare(String o1,String o2){
        return o1.compareTo(o2);
        }});
//如果是字符串比长度
        Collections.sort(v,new Comparator<String>(){
        public int compare(String o1,String o2){
        return o2.length()-o1.length();
        }});

ArrayList m=new ArrayList();
        m.add(31);
        m.add(6);
        m.add(56);
        Collections.reverse(m);

//从键盘输入一字符串，采用StringTokenizer类将该字符串里的单词按照空格，逗号和句号分隔出来，统计单词数，并按单词出现的顺序打印出来
package q3;
import java.util.*;
public class q3 {
    public static void main(String argc[])
    {
        Scanner s1=new Scanner(System.in);
        String s2=s1.nextLine();
        StringTokenizer st1=new StringTokenizer(s2," ,.");
        int num=0;
        while(st1.hasMoreTokens())
        {
            num++;
            System.out.println(st1.nextToken());
        }
        System.out.println("单词总数是："+num);
    }
}

//xxxValue()
//转换数据类型并返回
Integer x=5;
System.out.println(x.byteValue());
//compareTo()
//啥都可以比较，字符串有也可以比较
//equals()就不说了
//valueOf()
//就是定义的时候给定参数
Integer b= Integer.valueOf("11",16);//先转为16进制然后将其赋值给b
//toString()
//直接返回值，我觉得没啥软用
//parseInt()
//字符串转化为各种Number型
int x=Integer.parseInt("456");

//Scanner，汉字可以输出           
            File f=new File("E:\\text\\hello.txt");
            Scanner sc =new Scanner(f);
            while(sc.hasNextLine())
            {
                System.out.println(sc.nextLine());
            }
//InputStream && read，只能输出字幕
            File f=new File("E:\\text\\hello.txt");
            FileInputStream fis=new FileInputStream(f);
            byte[] all=new byte[(int)f.length()];
            fis.read(all);
            for(byte b:all) { System.out.println((char)b); }
//OutoutStream && write，将内容写入文件中
            FileOutputStream fos=new FileOutputStream(f);
            byte[] shuru[]={88,80};
            fos.write(shuru);

//读文件
File f = new File("d:/lol.txt");
FileReader fr = new FileReader(f))
char[] all = new char[(int) f.length()];
fr.read(all);
for (char b : all) {System.out.println(b);}
//写文件
String date="hello java";
char cs[]=data.toCharArray();
//不管怎么样只要有一个char类型的数组就可以了
fr.write(cs);

//实现将文件的复制
import java.io.*;
public class copy {
    public static void main(String a[])
    {
            try(
            BufferedWriter f2=new BufferedWriter(new FileWriter("E:\\text\\hello.txt"));
            BufferedReader f1=new BufferedReader(new FileReader("E:\\text\\hello1.txt"));
            )
            {  int judge=0;
                while((judge=f1.read())!=-1)
                {
                    f2.write(judge);
                }
            }
            catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//读取数据
        File ff = new File("E:\\text\\hello.txt");
        try(
                FileReader fr = new FileReader(ff);
                BufferedReader br = new BufferedReader(fr);
                )
        {
            while (true) {
                // 一次读一行
                String line = br.readLine();
                if (null == line)
                    break;
                System.out.println(line);
            }
        }
//写数据
        File ff = new File("E:\\text\\hello.txt");
        try(
                FileWriter f2 = new FileWriter(ff);
                )
        {
            String m="hello boy";
            f2.write(m);
        }

import java.io.*;
//实现从一个文件读取数据一直追加到另一个文件的末尾
public class copy {
    public static void main(String a[])
    {
            try(
            FileWriter fw=new FileWriter("E:\\text\\hello.txt",true);
            BufferedWriter f2=new BufferedWriter(fw);
            FileReader fr=new FileReader("E:\\text\\hello1.txt");
            BufferedReader f1=new BufferedReader(fr);
            )
            {
                String s1;
                while((s1=f1.readLine())!=null)
                {
                    f2.write(s1);
                }
                f2.flush();
            }
            catch (IOException e) {
            e.printStackTrace();
        }
    }
}

File f =new File("d:/lol.txt");
        try (
                FileInputStream fis  = new FileInputStream(f);
                DataInputStream dis =new DataInputStream(fis);
        ){
            boolean b= dis.readBoolean();
            int i = dis.readInt();
            String str = dis.readUTF();
            System.out.println("读取到布尔值:"+b);
            System.out.println("读取到整数:"+i);
            System.out.println("读取到字符串:"+str);
        } catch (IOException e) {
            e.printStackTrace();
        }

import java.io.*;
public class dd {
    public static void main(String[] args) {
        //创建一个Hero garen
        //要把Hero对象直接保存在文件上，务必让Hero类实现Serializable接口
        Hero h = new Hero();
        h.name = "garen";
        h.hp = 616;
        //准备一个文件用于保存该对象
        File f =new File("E:\\text\\hero.pp");
        try(
                //创建对象输出流
                FileOutputStream fos = new FileOutputStream(f);
                ObjectOutputStream oos =new ObjectOutputStream(fos);
                //创建对象输入流
                FileInputStream fis = new FileInputStream(f);
                ObjectInputStream ois =new ObjectInputStream(fis);
        ) {
            oos.writeObject(h);
            Hero h2 = (Hero) ois.readObject();
            System.out.println(h2.name);
            System.out.println(h2.hp);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

PrintStream ps=new PrintStream(new FileOutputStream("E:\\text\\hero.pp"));  
 System.setOut(ps);  
 System.out.println("Hello World!");

//创建一个文件
        File f=new File("E:\\text\\hh.ttx");
        try {
            f.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
//获取目录下的所有文件
        File f=new File("E:\\text");
        f.mkdir();
        String list[]=f.list();
        for(String kk:list)
        {
            System.out.println(kk);
        }

//第一个格式:
try
{
    //执行程序代码，可能会出现异常
}
catch()
{
    //捕获异常并处理
}
//第二个格式:
try
{
    //执行程序代码，可能会出现异常
}
catch()
{
    //捕获异常并处理
}
finally
{
    //一定会执行的代码;
}
//第三种格式
try
{
    //执行程序代码，可能会出现异常
}
finally
{
    一定会执行的代码;
}

/自定义异常
Class DemoException extends Exception
{
DemoException(String message)
{
//因为父类中已经把异常信息的操作都完成了。
//所以子类只要在构造时，将异常信息通过super语句传递给父类即可
super(message);
}
}

//自定义异常
public class HelloWorld {
  public static void main(String[] args) {
    MyDemo m=new MyDemo();
    try
    {
      int x=m.ok(3,-1);
      System.out.println("x="+x);
    }
    catch(FuShuException f)
    {
      System.out.println(f.toString());
      System.out.println("错误的负数是："+f.getValue());
    }
    System.out.println("over");
  }
}
class FuShuException extends Exception
{
  private int value;
  FuShuException()
  {
    super();
  }
  FuShuException(String msg,int value)
  {
    super(msg);
    this.value = value;
  }
  public int getValue()
  {
    return value;
  }
}
class MyDemo
{
  int ok(int a,int b) throws FuShuException
  {
    if(b<0)
      throw new FuShuException("分母出现了是负数的情况--/ by fushu",b);
    return a/b;
  }
}