Java复习知识点

Java课件上的知识点

1、静态方法和实例方法都允许被重载。
2、子类中的构造方法与父类中的构造方法-------------没有继承关系
3、子类中的静态方法与父类中可访问的静态方法同名同参不同返回值类型—可能错误
1、更改子类属性名称，不然系统默认你是重写父类的方法，因为返回类型不一致所以报错。
2、首先要看该方法的使用范围，
如果是private，那么这样定义是没有问题的。
如果不是private的。我们知道，子类是可以访问父类的非private方法。这样的话，如果子类有和父类同名不同返回类型的方法，就相当于在一个类中有两个同名不同返回类型的方法，这在java中犯了二异性的错误，是不允许的。
4、子类中的实例方法与父类中可访问的实例方法同名同参不同返回值类型—可能错误
//关于重载和覆盖的相关的知识点

Overload译为重载；Override译为重写或者覆盖；
Overload讨论：
Java中同一个类不可以有两个相同的方法（方法名、参数类型、参数个数和参数位置都
相同）。但可以有方法名相同，参数不同（参数类型、参数个数和参数位置不相同）的方法。这
种相同的方法名，参数不同的方法称为重载。
public class Test {
public void fn(String name) {}
public void fn(int age) {}
public void fn(String name, int age) {}
public void fn(int age, String name) {}
}
这个相信大家都知道，那么不同返回类型或者抛出的异常声明可以重载吗？答案是不可
以，那么为什么不可以呢？
public class Test {
public void fn(String name) {}
public String fn(String name) { //Error
return null;
}
public void fn(String name) throws Exception {} //Error
}
因为返回类型和抛出的异常声明是在执行完该方法（运行时）才知道的，所以fn
(“Bruce”)调用程序不知道去执行哪一个方法。
Override讨论：
重写意味着子类重写了一个和父类一样的方法，将父类的方法给覆盖掉了。
class Parent {
public void fn() {
int i = 1 + 1;
}
}
class Son extends Parent {
public void fn() {
int i = 8 - 3;
}
}
那么子类方法返回类型或者抛出的异常声明和父类不同是否可以？不可以，Java编译要
求子类方法返回类型必须和父类相同，抛出的异常声明可以小于或等于父类。
class Parent {
public void fn() throws RuntimeException {
int i = 1 + 1;
}
}
class Son1 extends Parent {
public void fn() {
int i = 8 - 3;
}
}
//NullPointerException是RuntimeException子类，所以可以
class Son2 extends Parent {
public void fn() throws NullPointerException {
int i = 8 - 3;
}
}
//RuntimeException和NullPointerException都可以上塑转型为RuntimeException，所以可以
class Son3 extends Parent {
public void fn() throws RuntimeException, NullPointerException {
int i = 8 - 3;
}
}
//Exception是RuntimeException的父类，大于RuntimeException类，所以不可以
class Son4 extends Parent { //Error
public void fn() throws Exception {
int i = 8 - 3;
}
}

5、子类中的实例方法与父类中可访问的静态方法同名同参同返回值类型—错误
6、在设计父类时建议显式地定义出无参的构造方法
7、instanceof
①可以将一个实例转换成一个父类的变量。称为向上转换，因为子类实例永远是它的父类的实例。当把一个父类的实例转换成它的子类变量（称为向下转换）时，
必须使用记号“（子类名）”进行显式转换，向编译器告诉你的意图。为使转换成功，需确保要转换的对象是子类的一个实例。如果父类对象不是子类的一个实例，
就会出现一个运行异常ClassCastException。
②没有继承关系的不同类的对象引用变量之间不能相互 转换。
8、抽象类的成员可以是（常量、实例变量、 静态变量、 构造方法、静态方法、实例方法），但不能包含静态的抽象方法、私有的抽象方法、final抽象方法
9、抽象方法只能出现在抽象类中，在非抽象类中不能定义抽象方法。
static、private和final修饰符不能用来修饰抽象类和 抽象方法。
10、子类可以定义为抽象类，即使它的父类是非抽象类。
11、接口
接口内部只能包含公有静态常量和公有抽象实例方法
接口的定义方法：
[public] interface 接口名称{
//静态常量及抽象方法
}
12、
public interface T{
public static final int K=1;
public abstract void p();
}
等价于
public interface T{
int K=1;
void p();
}
在Java接口中，编译器将常量的定义默认为public static final 类型的静态常量 类型的静态常量，不论是否使用了这些修饰符它都是这样处理的 。 所以在定义常量时，
可以只给出其数据类型说明和常量名，同时，定义时要为每个常量都赋值。因为成员方法都是抽象的，在定义成员方法时也可以省略关键字abstract，它默认也是抽象的。
13、在Java中，要让接口发挥其功能 ，需定义一个普通的类 ，在这个类要覆盖掉接口中的所有方法，以便将其实现，称为该类对接口的实现， 实现接口是通过关键字implements来说明。
14、 如果两个方法方法名称、参数列表相同，仅是返回值类 型不同，则在类中无法创建一个能满足两个接口的方法，需要对所实现的接口进行修改。
15、接口与抽象类的区别
 数据域区别：在接口中只能定义常量；
抽象类的数据域 则既可定义常量、也可定义变量。
 方法的区别：接口中的方法必须是公有抽象的实例方法， 没有其它类型的方法（包括构造方法也不存在）；
抽象类中的方法没有限制（存在构造方法，但不能用其实例化对象），但其抽象方法必须是可访问的抽象实例方法
 继承的区别：接口之间可以存在多重继承，接口不能继承类；
类之间只能单重继承 ，并且可以实现多个接口 。
16、 内部类可在其它类(非外部类)中使用，其实例化方式有两种：
a> 如果内部类是非静态的
外部类名.内部类名 内部对象名
=外部类对象.new 内部类构造方法
b> 如果内部类是静态的
外部类名.内部类名 内部对象名
=new 外部类名.内部类构造方法
17、只能在匿名内部类对含有一个抽象方法的接口实 现时才可用lambda表达式精简，如果匿名内部类所实 现的接口有两个或两个以上抽象方法则会出错。
18、异常处理
我们把生成异常对象并把它提交给运行时系统的过程称为抛出(throw)一个异常。
从生成异常的方法开始进行回朔，直到找到包含相应异常处理的方法为止，这一个过程称为捕获(catch)一个异 常。
所有的异常类都是从Throwable类派生而来的。Throwable类被包含在java.lang包中。
 必检异常：这类异常是指程序在编译时会强制程序员在程序中检查并处理的异常。
 免检异常：这类异常是指程序在编译时不会强制程序员在程序中检查并处理的异常。
19、声明异常的关键字是throws，抛出异常的关键字是throw。一 个方法总能抛出免检异常。如果一个方法要抛出必检异常，那么必
须在方法说明部分显式地声明这个异常。
当必检异常抛出时，必须用try-catch块捕获并处理它，或者不处理 但在调用它的方法中再次声明该异常
20、当必须处理必检异常时才使用try…catch；不要用 try…catch处理简单、可预料的情况。
21、I/O流分类
1> 根据I/O流数据格式分类
a. 二进制I/O流（字节I/O流）：文件或程序内存中的数据不需转化 直接读入或写出，I/O效率高。用户用记事本读经二进制流输出 得到的文件通常为乱码。
b. 文本 I/O流（字符I/O流）：文件或程序内存中的数据需经转化， 经解码读入或经编码写出。经文本流输出得到的文件通常可用 记事本打开，用户能读懂。
2> 根据访问文件的顺序类型分类
a. 顺序I/O流：进行文件读写操作时，必须从头开始 ，按顺序进行 。
b. 随机I/O流：允许从文件的任意位置进行读写。

Java课本上的知识点
1、标识符组成：字母、数字、下划线、美元符构成的字符序列。且标识符的开头必须以字母或者（_)开头，不能以数字开头。
2、boolean类型的数据默认为false的。且boolean类型的变量只能参与（==）、（！=）运算
3、false!=false 结果为false
4、%b 布尔值 %c 字符 %d 十进制整数 %f 浮点数 %e 标准科学计数法形式的数 %s 字符串
5、 可以使用equals和compareTo方法比较字符串。如果两个字符串相等，equals方法返回true;如果他们不等，则返回false。compareTo方法根据一个字符串等于、大于或小于另一个字符串，分别返回0、正整数或者负整数。
6、字符串的值包含在一对匹配的（“ ”）中，而字符的值则包含在一对匹配的（‘ ’）中。
7、 在方法体内部也可定义变量。一般将方法体内定义的变量称为局部变量。局部变量是没有默认值的，当局部变量未赋值而又直接对其引用时，编译将报错。
8、 方法不能嵌套定义 ，但可嵌套调用，同时，Java中的成员方法在定义时还支持递归调用。
9、一维数组的反转
程序如下：
方法1：
import java.util.Scanner;
public class ArrayReverse {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int[] list=new int[10];
for(int i=0;i<list.length;i++) {
list[i]=input.nextInt();
}

         for(int i=0;i<list.length;i++) {
                System.out.print(list[i]+" ");
         }
         
         System.out.println();
         System.out.println("--------------------");
         
         int[] list2=reverse(list);
         
         for(int i=0;i<list2.length;i++) {
                System.out.print(list2[i]+" ");
         }
   }     
   
   //程序反转的方法体 
   public static int[] reverse(int[] list) {
         int[] result=new int[list.length];
         for (int i=0,j=result.length-1;i<list.length;i++,j--) {
                result[j]=list[i];
         }
         return result;
   }

}

方法2：
import java.util.Scanner;
public class ArrayReverse1 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int[] list=new int[10];
for(int i=0;i<list.length;i++) {
list[i]=input.nextInt();
}

         for(int i=0;i<list.length;i++) {
                System.out.print(list[i]+" ");
         }
         
         System.out.println();
         System.out.println("--------------------");

/*
*
* 仅仅只需反转到一半处即可，无论是偶数个还是奇数个只需反转到
* （n/2)处即可。例如5个数，5/2结果为2，第三个数是没有必要进行
* 反转的，当为4个数是，4/2结果为2，显然反转到第2个数的时候就
* 可以了。所以写为i<(list.length/2)
*
*/

         for(int i=0,j=list.length-1;i<(list.length/2);i++,j--) { 
                int temp=list[i];
                list[i]=list[j];
                list[j]=temp;
         }
         
         for(int i=0;i<list.length;i++) {
                System.out.print(list[i]+" ");
         }
   }

}

10、求素数
程序如下：
public class SuShuText {
public static void main(String[] args) {
int i,j,count=1;
//System.out.print(i+" “+j+” “+count+” ");
for(i=100;i<=200;i++) {
for(j=2;j<=i/2;j++) {
if(i%j==0)
break;
}
//for 2

                /*
                 *
                 * 算法分析：
                 * 一个数如果是素数，那么就不能存在除了1和它本身之外的数可以整除它。
                 * 所以如果一个数不是素数，那么它至少能被某个不为1和它本身的数除为2，
                 * 即被分为两份，所以只需要算到自己想要判断的数据的一半处即可。后边
                 * 的那部分便无需再做判断。所以如果直到j>i/2还不能找到一个能整除该数
                 * 的数那么这个数一定是素数。
                 *
                 */
                if(j>i/2) {   
                       System.out.print(" "+i);
                       count++;
                }
                
                //每5个换一次行
                if(count%6==0) {
                       System.out.println();
                       count=1;
                }
                
         }
            //for 1
   }      //main

} //SuShuText
11、数组类型.length 其他的使用.length都不是正确的
12、数组1数组2 作用：判断两个数组的地址是否一致
13、循环体
for循环&&while循环
for循环代码：
public class XunHuanTi2Text {
public static void main(String[] args) {
int sum=0;
for(int i=0;i<4;i++) {
System.out.println(“i=”+i);
if(i%30) continue;
System.out.println(“a”);
sum+=i;
}
System.out.println(“sum=”+sum);
}
}

while循环代码：
public class XunHuanTi3Text {
public static void main(String[] args) {
int i=0,sum=0;
while(i<4) {
System.out.println(“i=”+i);
if(i%30) {
i++; //此处必须有i++;否则在（i%30）时，将跳不出循环体，从而成为一个死循环
continue;
}
sum+=i;
i++;
System.out.println(“a”);
}
System.out.println(“sum=”+sum);
}
}

这两个循环的输出是一样的。
14、 可以在void方法中使用return语句，该方法只退出该方法。但是return语句不能在void方法中返回诸如return x + y之类的值。
15、形参：定义在方法头中的变量
实参：在调用方法时，给参数传递的一个值
方法签名：方法名和参数列表共同组成的。
16、实参可以和形参有相同的名称。
17、 在方法中只能指定一个可变长度参数，该参数必须是最后一个参数。方法返回类型不能是可变长度参数。
18、 数组是一个对象。数组可以包含对象类型的元素。数组元素的默认值是0表示数字，false表示布尔值，’\ u0000’表示char，null表示对象元素类型。
19、如果一个变量依赖于类的某一个实例，那么就将它声明为实例变量或者实例方法。如果一个变量或者方法不依赖于任何类的某个具体实例，就将它定义为静态变量或者静态方法。
一个类是不能直接通过 类名.实例变量（方法）去访问实例的变量或者调用实例的方法的。但是一个该类的对象却可以调用实例方法、静态方法、访问实例变量和静态变量。
20、