数据结构day2

选择题

A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：

1. A a0=new A();
2. A a1=new B();
3. A a2=new C();

问以下哪个说法是正确的（）

A 只有第一行能通过编译
B 第1、2行能通过编译，但第3行编译出错
C 第1、2、3行能通过编译，但第2、3行运行时出错
D 第1行，第2行和第3行的声明都是正确的

知识点：继承

   Java支持单继承，一个子类只能由一个直接父类；可以有多个间接父类（除直接父类外的父类都叫间接父类，比如爷爷类），它们都叫做子类的父类。只要是父类的非私有属性和方法，非构造方法，都可以被子类继承。

2，阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）

public class Inherit02 {
    public static void main(String[] args) {
        MyAppliction myAppliction = null;
        myAppliction.hello();
    }
}
class MyAppliction{
    public static void hello(){
        System.out.println("hello");
    }
}

 A 能编译通过，并正确运行
B 因为使用了未初始化的变量，所以不能编译通过
C 以错误的方式访问了静态方法
D 能编译通过，但因变量为null，不能正常运行

知识点：静态方法静态类

    MyAppliction类的hello方法是静态的，所以是属于类的，当实例化该类的时候，静态会被优先加载而且只加载一次，所以不受实例化new Test();影响，只要是使用到了Test类，都会加载静态hello方法。

4. 在使用super和this关键字时，以下描述正确的是（）

 A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B super（）和this（）不一定要放在构造方法内第一行
C this（）和super（）可以同时出现在一个构造函数中
D this（）和super（）可以在static环境中使用，包括static方法和static语句块

知识点：super和this关键字

（1） this和super都只能在对象内部使用。
（2）this代表当前对象本身，super代表当前对象的父类型特征。
（3）this.”是一个实例对象内部为了区分实例变量和局部变量。
         而“super.”是一个实例对象为了区分是子类的成员还是父类的成员。
（4）父类有，子类也有，子类想访问父类的，“super.”不能省略。
（5）super和this(本类的构造方法)关键字都只能出现在构造方法的首行
（6）使用super的前提是必须有继承关系

7. 下列哪一种叙述是正确的（）

 A abstract修饰符可修饰字段、方法和类    //不可以修饰字段
B 抽象方法的body部分必须用一对大括号{ }包住   //没有方法体
C 声明抽象方法，大括号可有可无    //没有大括号
D 声明抽象方法不可写出大括号

知识点：abstract

抽象类：抽象类就是比普通类多了一些抽象方法，是普通类的超集。抽象类和抽象方法使用abstract关键字来定义，抽象方法所在的类一定是抽象类。

（1）抽象方法用abstract来声明，只有方法声明，不包含方法体。方法体就是{}；

（2）抽象类必须有子类，因为抽象类不能自己实例化对象，要通过子类对象向上转型为其实例化。

（3）子类继承抽象类，如果子类是普通类，需要重写抽象类中的所有抽象方法，如果子类是抽象类，可以有选择的重写抽象类的抽象方法。

public abstract class Animal {
    // 抽象方法
    public abstract void eat();
    public abstract void sleep();
}

下列说法正确的有：（）
A class中的constructor不可省略
B constructor必须与class同名，但方法不能与class同名
C constructor在一个对象被new 时执行
D 一个class只能定义一个constructor

知识点：Class类的constructor方法

     Constructor方法则是Class中最重要的方法之一,它用于创建和初始化对象。     

     constructor方法是Class类的默认方法，通过new命令，创建一个新的实例对象时，会自动调用此方法。

      一个类必须有constructor()方法，如果创建类的时候，没有显示的定义该方法，一个空的 constructor()方法会被默认添加。

     class中的constructor是可以省略的；

     Constructor必须与clas同名，方法也可以与class同名，区别在方法有void或具体返回值类型；

      Constructor在对象被new的时候执行，如果该对象有父类的话会在当前对象的构造方法中默认先调用父类的构造方法super()；

     class的constructor构造方法是支持重载的，所以一个class可以定义多个constructor。

9.选项中哪一行代码可以替换 //add code here 而不产生编译错误

public abstract class MyClass {
      public int constInt = 5;
     //add code here
     public void method() {
    }
}

 A public abstract void method(int a);
B consInt=constInt+5;   //这里对成员变量的赋值只能放在方法的内部
C public int method();    //这method 不是抽象方法， 所以 不能省略{}
D public abstract void another Method(){}  //抽象没有结构体

知识点：抽象类和抽象方法

在使用 interface 声明一个外部接口时，只可以使用（ ）修饰符修饰该接口。

A private
B protected
C private protected
D public

知识点：接口

接口中，public描述属性，static final描述常量，abstract描述抽象方法

（1）接口中，只存在抽象方法和全局常量，因此，在接口定义中，以上关键字可以省略，且阿里编码规定，以上关键字不要出现在接口定义中；

（2）子类可以同时继承多个接口

（3）先继承，在implements

（4）接口不能使用extends继承子类，但是接口可以使用extends来继承父类，也可以继承多个。

编程题

 1. ACM编程题 标题：排序子序列 | 时间限制：1秒 | 内存限制：32768K
     牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数
组分为几段排序子序列.
输入描述：输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)
                  第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。
输出描述：输出一个整数表示牛牛可以将A最少划分为多少段排序子序列
示例1:
输入   6
          1 2 3 2 2 1
输出    2

题目解析：非递减就是a[i]<=a[i+1]，递减a[i] > a[i+1]

                  非递增就是a[i]>=a[i+1]，递减a[i] < a[i+1]

思路：

     比较整个数组
     a[i+1]>a[i] ，则进入非递增序列判断，直到遍历到下一个值不大于等于为止count++，然后进行下一位置的判断
     a[i+1]<a[i]，则进入非递增序列判断，直到遍历到下一个值不小于等于为止count++，然后进行下一位置的判断
     a[i+1] == a[i]不进行操作，i++进行下一位置遍历，因为相等既可以属于非递增序列，也可以属于非递减序列，不在进行其他操作。

     因为i+1，所以为防止越界，数组长度为n+1

import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        int[] array = new int[n+1] ;
        for(int i = 0;i<n;i++){
            array[i] = in.nextInt();
        }
        int i = 0;
        int count = 0;
        while(i<n){
            if(array[i]<array[i+1]){
                while(i<n && array[i]<=array[i+1]){
                    i++;
                }
                count++;
                i++;
            }else if(array[i]==array[i+1]){
                i++;
            }else{
                while(i<n && array[i]>=array[i+1]){
                    i++;
                }
                count++;
                i++;
            }
        }
        System.out.println(count);
    }
}