Java基础知识补充（实例）

数组倒序

将一个数组逆序输出。

public class JavaTest1 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入要逆序的数组的长度");
        int length=scanner.nextInt();
        int[] arr1=new int[length];
        System.out.println("请输入要逆序的数组的元素");
        for(int i=0;i<arr1.length;++i)
            arr1[i]=scanner.nextInt();
        int[] arr2=new int[arr1.length];
        for(int i=0;i<arr1.length;++i){
            arr2[arr1.length-1-i]=arr1[i];
        }
        for(int j=0;j<arr2.length;++j){
            System.out.print(arr2[j]+"\t");
        }
    }
}

字符串排序

public class JavaTest40 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入字符串的数量");
        int length=scanner.nextInt();
        String[] arr=new String[length];
        System.out.println("请输入字符串，用空格分隔开");
        for(int i=0;i<arr.length;++i)
            arr[i]=scanner.next();
        sortString(arr);
        for(int i=0;i<arr.length;++i){
            System.out.print(arr[i]+" ");
        }
    }
    public static void sortString(String[] arr){
        for(int i=0;i<arr.length;++i){
            for(int j=0;j<arr.length-1-i;++j){
                if(arr[j].compareTo(arr[j+1])>0){
                    String temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

关键字

1.final关键字

1.fianl关键字的作用
​ final代表最终的意思，可以修饰成员方法，成员变量，类

2.final修饰类、方法、变量的效果
​ fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
final修饰方法：该方法不能被重写
​ final修饰变量：表明该变量是一个常量，不能再次赋值

3.fianl修饰基本数据类型变量
​ final 修饰指的是基本类型的数据值不能发生改变

4.final修饰引用数据类型变量
​ final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

2. static关键字

1.static的概念
​ static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

2.static修饰的特点
​ 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
可以通过类名调用当然，也可以通过对象名调用

3.static的访问特点
（1）非静态的成员方法
​ 能访问静态的成员变量
​ 能访问非静态的成员变量
​ 能访问静态的成员方法
​ 能访问非静态的成员方法
（2）静态的成员方法
​ 能访问静态的成员变量
​ 能访问静态的成员方法

3. super和this关键字

1.this：代表本类对象的引用
super：代表父类存储空间的标识(可以理解为父类对象引用)
this和super的使用分别

2.成员变量：
this.成员变量 - 访问本类成员变量
super.成员变量 - 访问父类成员变量

3.成员方法：
​ this.成员方法 - 访问本类成员方法
​ super.成员方法 - 访问父类成员方法

4.构造方法：
​ this(…) - 访问本类构造方法
​ super(…) - 访问父类构造方法

内部类

内部类：将一个类定义在另一个类里面或者一个方法里面

成员内部类

1、成员内部类：
成员内部类看起来像是外部类的一个成员，所以内部类可以拥有private、public等访问权限修饰；当然，也可以用static来修饰。成员内部类分为：

静态成员内部类：使用static修饰类；
非静态成员内部类：未用static修饰类，在没有说明是静态成员内部类时，默认成员内部类指的就是非静态成员内部类；
注：只有成员内部类才能加static变成静态内部类。

（1）静态内部类

class OutClass {
 	static class InnerClass {
      static String test = "test";
      int a = 1;
      static void fun1() {}
      void fun2() {}
  }
}

（2）非静态内部类

public class Circle {
  private double radius = 0.0;
  public static int count = 1;
  public Circle(double radius) {
    this.radius = radius; 
  }
 public class Draw {
    public void drawSahpe() {
      System.out.println(radius);
      System.out.prinlt(count);
  }
}

局部内部类

局部内部类是在方法中定义的类，以外界是无法直接使用，需要在方法内津对象并使用
该类可以续访问外部类的成员，也可以访问方法内的局部变量

 	public void test() {
		class InnerClass {
			private String name;
			final static String test = "1";
			public InnerClass(String name) {
				super();
				this.name = name;
			}
			public void say(String str) {
				System.out.println(name+":"+str);
			}
		}
		new InnerClass("test").say("hello");
	}

匿名内部类

前提：存在一个类或者接口，这果的类可以是具体类也可以抽象类

public class Demo {
    private Runnable runnable = new Runnable() {
        @override
        public void run() {}
    }
}

异常

定义：在程序运行过程中出现的错误，称为异常。异常就是程序运行过程中出现了不正常现象导致程序的中断。在Java中，把各种异常现象进行了抽象形成了异常类。

分类：检查时异常；运行时异常；错误。

1.检查时异常：检查时异常最具有代表性的就是用户错误或者是问题引起的异常，这种异常是我们程序员无法进行预测的。例如我们要打开一个文件时文件不见了，这些异常都是在编译时不能被简单的忽略的。
2.运行时异常：运行时异常是可能被程序员避免的异常，与检查时异常相反，运行时异常可以在编译时被忽略。
3. 错误：错误不是异常，而是不被程序员控制的问题，错误在代码中通常被忽略。例如当栈溢出时，错误就产生了，并且在程序编译的时候也无法被找到。

抛出以及捕获异常

 try：抛出异常（尝试着去处理什么东西）。

 catch：捕获异常。

 final：无论有什么异常发生，finally都会被执行（可以运行清理类型等收尾善后性质的语句）。

 throw：当程序发生异常而无法处理的时候，会抛出对应的异常对象。

 throws：throws用来在类中捕获异常信息，标明方法可能抛出的异常。

自定义异常

定义：使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常，用户自定义异常类，只需要继承Exception类即可。

在程序中使用自定义异常类步骤

  1.创建自定义常类。

  2.在方法中通过throw关键字抛出异常。

  3.如果在当前抛出异常的方法中处理异常，可以使用try——catch语句来捕获异常并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用的异常，继续下一步操作。

  4.在出现异常方法的调用者中捕获并处理异常。