苏州大学文正学院java期末复习

Java基本概念部分

1. Java是1995年Sun公司正式推出更名，2010后被Oracre公司收购。Java对大小写敏感。

2. Java分为Java SE标准版 ，Java EE企业版和Java ME微型版。

3.字节码（低级语言）是由编译器产生，交由java虚拟机读取和解释。

4.导包的关键词import，若不导包则必须写出全路径。

5.Java支持统一码（Unicode）

6.单引表示字符，双引表示字符串。

7.字符串String，StringBuilder类。

8.final 修饰常量的关键字

final修饰变量    常量

final修饰类    类是终极类，不可扩展

9.Math.random( )-------------- ( 0.0 , 1 ]

返回一个i ~ j随机整数:  (int)(i+Math.random( )*(j-i+1))

           返回ch1~ch2的随机字符：(char)(ch1 + Math.random()*(ch2-ch1+1))

10.Switch选择语句。

Continue只是跳出了一次迭代，break跳出了整个循环。

11.构造方法的特性：

                1. 构造方法必须具备和所在类相同的名字。

                2．构造方法没有返回类型，没有void

3. 构造方法是在创建一个对象使用new操作符的时调用的。构造方法的作用是初始化对象

12.引用变量和引用类型：

                1.对象是通过对象引用变量来访问的，该变量包含对对象的引用。

2.一个类基本等同于一个程序员定义的类型。一个类就是一种引用对象，这意味着任何类型为类的变量都可以引用该类的一个实例。

13.面向对象的三个基本特征：1. 封装    2. 继承        3. 多态

14.一个文件中可以有多个类但是只能有一个公共类。

15.this和super关键字

        this表示调用自己

        super表示调用父类

16.FlowLayout是最简单的布局管理器。按照组件添加的顺序，从左到右地将组建排列在容器中，当放满一行时就开始新的一行。 

17.三种异常类型：

            系统错误：内部系统错误，由Jvm抛出用Error类表示。（免检异常）

            异常：    程序和外部环境所引起的错误，用Exception类表示。（必检异常）

            运行时异常：程序设计错误，用RuntimeException类表示。（免检异常）

18.声明一个异常关键字    throws

抛出一个异常关键字    throw

捕获一个异常关键字    try{  } catch( ){ }

19.：源对象触发一个事件，对此事件感兴趣的对象会处理它，将对此事件感兴趣的对象成为。

20..applet的生命周期方法。

    Start 在init方法之后就会调用。

代码部分

1.显示闰年

2.public class Leap{

3.     static boolean leap( int year ){

4.            if ( year % 400 == 0)

5.                return true;

6.            else if ( year % 100 != 0 && year % 4 == 0 )

7.                    return true;

8.                else

9.                    return false;

10.                }

11.        public static void main ( String[] args ){

12.            Int [] year = new int [200];

13.            int flag = 0;

14.            //输出从2004年到2204年的闰年并且按照每10个为一行输出

15.            for(int i = 0 ; i < 200 ; i++) {

16.                year[ i ]= i+2004;

17.                if ( leapdemo( year[ i ] ) ){

18.                    flag ++;

19.                    System.out.print( year[ i ] + " ");

20.                    if ( flag % 10 == 0 )

21.                        System.out.println( );        

22.                    }

23.                }

24.                System.out.println( );    

25.            }

26.     }

1.显示素数

2.public class Prime {

3.    static boolean prime(int num){

4.            if(num==1)

5.                return false;

6.            for(int i = 2 ; i <=Math.sqrt(num);i++){

7.                if(num%i==0)

8.                    return false;

9.            }

10.                return true;

11.        }

12.     public static void main(String[] args){

13.        //输出从2到200的素数并且按照10个一排输出

14.            int flag = 0;

15.            for(int i = 2 ; i < 200 ; i++ ){

16.                if(prime(i)){

17.                    flag++;

18.                    System.out.print(i+" ");

19.                if(flag%10==0)

20.                    System.out.println();

21.                }

22.            }

23.            System.out.println( );        

24.     }

25.}

1.UML图写Circle类

2.public class Circle {

3.

4.        public static void main(String[] args) {

5.            Circle c1 = new Circle();

6.            System.out.println(c1);

7.        

8.            Circle c2 = new Circle(25);

9.            System.out.println(c2);

10.        

11.            c2.radius = 100;

12.            System.out.println(c2);

13.        }

14.

15.        double radius;

16.        public Circle() {

17.            radius = 1.0;

18.        }

19.        public double getRadius() {

20.            return radius;

21.        }

22.        public String toString() {

23.            return "The area of the circle of radius " + getRadius()

24.                    + " is " + getArea() ;

25.        }

26.        public void setRadius(double radius) {

27.            this.radius = radius;

28.        }

29.        public Circle(double radius) {

30.            this.radius = radius;

31.        }

32.        double getArea() {

33.            return radius * radius * Math.PI;

34.        }    

35.}

1.UML图写Course类

2.public class Course {

3.        private String courseName;

4.        private String[] students = new String[100];

5.        private int numberOfStudents;

6.        public Course(String courseName) {

7.            this.courseName = courseName;

8.        }

9.        public void addStudent(String student) {

10.            students[numberOfStudents] = student;

11.        }

12.        public String[] getStudents() {

13.            return students;

14.        }

15.        public int getNumberOfStudents() {

16.            return numberOfStudents;

17.        }

18.        public String getCourseName() {

19.            return courseName;

20.        }

21.        public void dropStudent(String student){

22.            ArrayList array = new ArrayList();

23.            int i = 0;

24.            while(students[i]!=null){

25.                if(!student.equals(students[i])){

26.                    array.add(students[i]);

27.                }

28.                array.toArray(students);

29.                i++;

30.            }

31.        }

1.二分查找        

2.public int trad(int list [ ] , int n) {

3.        int head = 0;

4.        int tail = list.length - 1;

5.        int mid;

6.        while (head <= tail) {

7.            mid = (head + tail) / 2;

8.            if (n < list[mid]) {

9.                tail = mid - 1;

10.            } else if (n == list[mid]) {

11.                return mid + 1;

12.            } else  {

13.                head = mid + 1;

14.            } 

15.        }

16.        return -1;//表示不存在

17.    }

解答题

1.覆盖和重载的异同

1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。

2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。

3、覆盖要求参数列表相同；重载要求参数列表不同。

4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

       overload编译时的多态                       override运行时的多态

2.抽象类和接口的区别

    实例变量是绑定到类的的某个特定实例的，它是不能被同一类的不同对象所共享的。

    静态变量（类变量）的所有实例共享数据。

4. public,    private, protected三者修饰数据和方法的区别。