JAVA考点复习（2017-2018）

1. 合法标识符

严格区分大小写、unicode标准字符集

不能以数字开头 、不能是关键字、不能有空格

2. final 关键字

   修饰的类不能被继承

   修饰的成员变量是一个常量（大写字母）

   修饰的成员方法不能被子类重写

 Static： 所有变量共享一个变量

 静态类不可以实现接口和继承抽象方法（与最终类有区别）

3. try –catch –finally –

  不管是否捕捉到异常均执行finally语句

  Finalize()清理垃圾 清楚内存空间 类似析构函数

4.++a 在使用a之前，先使a的值加1

  a++在使用a之后，使a的值加1

 例：a=4  b=++a b=5 a=5

         b=a++  b=4 a=5

5.隐式转换：低到高

  显示转换：高到低 inta=(int)45.23;

6. switch 若case中无break 则循环一直执行

  foreach语句：for(元素变量x:遍历对象obj){引用了x的java语句}

7.break ：嵌套循环时只跳出一层循环

 continue：跳出本次循环后再进行循环

8.声明一维数组：1）int arr[];

               arr=new int[5];

           2)int arr[]=new int[5];

         创建并初始化int arr[]=new int[]{31,28,31,30};

 声明二维数组1）int arr[][];

                 arr=newint[2][4];

             2) int arr[][]=new int[2][4];

        创建并初始化intarr[][]={{31,28},{31,30}};

9.二维数组的遍历：

  1）for(intk=0;k<arr.length;k++){

      for(int c=0;c<arr[k].length;c++){

System.out.print(arr[k][c]);

}   System.out.print();   }

 2)  int i=0; 

for(int x[]:arr){ i++;

int j=0;

for(int e:x){ j++;

if(i==arr.length&&j==x.length){

 s.o.p(e);}else

s.o.p(e+”、”); } } }

 [Trim() 删除空格例子：String s=” Hello World ”.trim(); 把前后的空格删除

 Replace() 替换 ReplaceAll()替换所有 ]

10.面向对象思想

   1）子类不能继承构造方法，若调用则需super语句（且在第一行）

   2）方法重载：静态 在同一个类中。定义参数不一致。

     方法覆盖（=重写）：动态（override）在不同类中。需继承。

                权限可以扩大，不能缩小。返回值和方法名要一致。

 11.集合和泛型

1）Collection接口

   Collection<String> list=newArrayList<>();

    list.add(“a”);

    Iterator<String> it=list.iterator();//创建迭代器

    while(it.hasNext()){//判断是否有下一个元素

       String str=(String)it.next();//获取集合中的元素

s.o.p(str );}}

--List：（有序）将以特定次序存储元素。（可以重复）
            --ArrayList / LinkedList / Vector
       --Set ：（无序）（不能含有重复）的元素
            --HashSet /TreeSet

使用next()获得序列中的下一个元素。

　　使用hasNext()检查序列中是否还有元素。

　　使用remove()将迭代器新返回的元素删除。

 

   2)Map接口（有序）

--HashMap
    --TreeMap

12.JDBC连接数据库

   加载驱动 -驱动管理类（生成对象）-语句对象（执行SQL语句）-（查询语句等等方法）

增删查改

13.接口 interface

   extend继承

   inplement 实现接口

14.值传递：实参传递值给形参不影响实参的值

   引用传递：实参传递地址给形参 会影响到实参

15面向对象的思想 4个特性 用什么机制实现？

    ①封装  （set get 不同访问权限对应的访问范围  修饰类或成员的时候的访问权限的区别）

public方法是外部类访问该类成员变量的入口

任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

    ②继承

class 子类名 extends 父类名{} 

（类型转换  所有的子类对象都可以赋值到父类引用 反过来赋值的时候 要进行判断 instance of  子类可以继承父类所有成员  除了构造方法 要调动构造方法 用super（参数名应该怎么写） super也能调用所有的成员方法 但调用构造方法必须在方法体的第一条） 

子父类中构造方法的用法：

子类的初始化过程中，首先回去执行父类的初始化动作。因为子类的构造方法中默认有一个super()。子类要使用父类的成员变量，这个初始化，必须在子类初始化之前完成。所以，子类的初始化过程中，会先执行父类的初始化。

如果父类没有无参构造方法

使用super调用父类的带参构造。推荐方式。

使用this调用本身的其他构造。

    ③多态（动态绑定  静态绑定  方法重载  方法覆盖  方法体和方法头部是什么关系  ） 执行的是同一条语句 

多态是对象在不同时刻表现出来的不同状态。

多态的前提：

要有继承或者实现关系。

要有方法的重写。

要有父类引用指向子类对象。

比如：

Parent p = new Child();

    ④抽象 abstract class

不能实例化对象  只能被继承使用（只能单进程 多进程可用接口  不能实例化对象就可以定义引用 抽象类 ）

   

 只要有相应的类

super和this有什么区别?

super是一个关键字，代表父类的存储空间标识。(可以理解为父亲的引用)

super和this的用法相似。

this代表对象的引用(谁调用就代表谁)；

super代表当前子类对父类的引用。

使用场景

当子父类出现同名成员时，可以用super进行区分；

子类要调用父类构造函数时，可以使用super语句。

区别

1.成员变量

this.变量   --   本类的

super.变量   --   父类的

2.构造方法

this(...)    --   本类的

super(...)    --   父类的

3.成员方法

this.方法名()   --   本类的   

super.方法名()   --   父类的

super();和this();都是在构造函数的第一行，不能同时出现。

 

 

题目一：

编写一个类Myclass，通过函数重载，实现以下结果：

当参数为两个整数时，返回两个整数的和。

当参数为两个小数时，返回两个小数的和。

当参数为两个字符串时，返回两个字符串的和。

package实验一;

 

import java.util.Scanner;

 

publicclass题目一 {

 

    publicstaticvoid main(String[] args) {

        // TODO Auto-generated method stub

       Myclass m=new Myclass();

       Scanner in=new Scanner(System.in);

       System.out.println("请输入参数类型（0整数，1小数，2字符串）");

       intx=in.nextInt();

       if(x==0)

       {

           System.out.println("请分别输入两个参数：");

           inta=in.nextInt();

           intb=in.nextInt();

           System.out.println(m.add(a, b));

       }

       if(x==1)

       {

           System.out.println("请分别输入两个参数：");

           doublec=in.nextDouble();

           doubled=in.nextDouble();

           System.out.println(m.add(c, d));

       }

       if(x==2)

       {

           System.out.println("请分别输入两个参数：");

           String e=in.next();

           String f=in.next();

           System.out.println(m.add(e, f));

       }

    }

 

}

class Myclass

{

    publicint add(intx,inty)

    {

        returnx+y;

    }

    publicdouble add(doublex,doubley)

    {

        returnx+y;

    }

    public String add(String x,Stringy)

    {

        returnx+y;

    }

}

题目二：

定义一个Person类和它的子类Employee。Person类有姓名、地址、电话号码和电子邮箱，然后定义一个方法showMessage()用于输出人的信息。Employee类有办公室、工资和受聘日期成员变量，定义一个方法showMessage用于输出雇员的信息。将Employee定义为public类，在其main()方法中分别为基于父类和子类创建两个对象，并分别为父类和子类的成员变量赋值，然后分别调用父类和子类的showMessage()方法来输出信息。

package实验一;

 

import java.util.Scanner;

 

publicclass题目二 {

 

    publicstaticvoid main(String[] args) {

        // TODO Auto-generated method stub

        PeopleA =new People();

        EmployeeB=new Employee();

        A.showMessage();

        System.out.println("显示员工的信息");

        B.showMessage();

    }

 

}

class People

{

    public String name;

    public String add;

    publicintnum;

    public String email;

    publicvoid showMessage()

    { 

       

        System.out.println("请输入员工的姓名");

        Scannerinput=new Scanner(System.in);

         name = input.next();

        System.out.println("请输入员工的地址");

         add=input.next();

        System.out.println("请输入员工的电话");

         num=input.nextInt();

        System.out.println("请输入员工的邮箱");

        email=input.next();

    }

}

class Employee extends People

{

    public String bangong;

    publicintgongzi;

    public String date;

    publicvoid showMessage() {

        super.showMessage();

        System.out.println("员工的姓名是："+name+"家住"+add+"，电话是："+num+"，邮箱是："+email+"");

    }

}

 

 

题目三：（抽象类，多态，继承）

设计一个学生抽象类，包括学号、学生姓名和班级状态及学生注册、学生注销的操作，再设计一个本科生类和研究生类，分别实现注册和注销的操作，最后设计一个学生管理类，完成不同学生的注册和注销。

package实验一;

 

publicclass StudentManager {

    publicvoid add(Students s)

    {

        s.logIn();

    }

    publicvoid delete(Students s)

    {

        s.clearOut();

    }

   

    publicstaticvoid main(String[] args) {

        // TODO Auto-generated method stub

        StudentManager manager=new StudentManager();

        Students underGraduate=new UnderGraduate();

        Students graduate=new Graduate();

        manager.add(underGraduate);

        manager.delete(underGraduate);

        manager.add(graduate);

        manager.delete(graduate);

    }

   

 

}

abstractclass Students

{

    public String id;

    public String name;

    public String className;

    publicabstractvoid logIn();

    publicabstractvoid clearOut();

}

class UnderGraduate extends Students

{

    publicvoid logIn()

    {

        System.out.println("本科生注册，注册成功！");

    }

    publicvoid clearOut()

    {

        System.out.println("本科生注销，注销成功！");

    }

}

class Graduate extends Students

{

    publicvoid logIn()

    {

        System.out.println("研究生注册，注册成功！");

    }

    publicvoid clearOut()

    {

        System.out.println("研究生注销，注销成功！");

    }

   

}

 

题目四：

定义不同的类，通过接口实现分别计算三角形，长方形和椭圆形的面积。

package实验一;

 

import java.util.Scanner;

 

publicclass题目四 {

 

    publicstaticvoid main(String[] args) {

        // TODO Auto-generated method stub

        Scannerin=new Scanner(System.in);

           System.out.println("请输入形状（0长方形，1三角形,2椭圆）");

           intx=in.nextInt();

           if(x==0)

           {

               System.out.println("请分别输入长和宽：");

               doublea=in.nextDouble();

               doubleb=in.nextDouble();

               System.out.println("矩形 "+new Rectangle(a,b).area());

           }

           if(x==1)

           {

               System.out.println("请分别输入两边长：");

               doublec=in.nextDouble();

               doubled=in.nextDouble();

               System.out.println("三角形 "+new Triangle(c,d).area());

           }

           if(x==2)

           {

               System.out.println("请分别输入长短半轴：");

               doublee=in.nextDouble();

               doublef=in.nextDouble();

               System.out.println("椭圆 "+new Tuyuan(e,f).area());

           }

    }

 

}

abstractclass Shape{

    abstractdouble area();

}

class Rectangle extends Shape {

    privatedoublew;

    privatedoubleh;

 

    public Rectangle(doublew, doubleh) {

        this.w = w;

        this.h = h;

    }

    double area() {

        returnw * h;

    }

}

class Triangle extends Shape {

    privatedoubleh;

    privatedoublel;

 

    public Triangle(doubleh, doublel) {

        this.h = h;

        this.l = l;

    }

    double area() {

        return 0.5 * h * l;

    }

}

class Tuyuan extends Shape

{

    privatedoublea;

    privatedoubleb;

    public Tuyuan(doublea,doubleb)

    {

        this.a=a;

        this.b=b;

    }

    double area()

    {

        return 3.14*a*b;

    }

}