Day 2

只要产生新的对象，==一定不成立

引用对象test为null，直接调用成员方法会报错，但此时方法是一个静态方法，不依赖于对象，所以能编译通过



必须放在子类构造方法的第一行，否则会报错


this和super是绝对不能出现在同一个构造方法中的，因为他们都要在第一行

this和super都和对象有关，static是不依赖于对象的，所以肯定不能在静态环境下使用this和super关键字


不管是静态方法还是普通方法都不能定义静态变量。静态变量只能定义在类中



可以修饰类和方法，但不能修饰字段

不可以加{}，{}大括号代表已经实现了方法，必须没有{}大括号。普通方法可以加大括号

可以省略编译器默认是无参构造
构造方法也是一种方法，所以是可以与类同名（易错点）
构造方法可以重载

A：抽象方法正确
B：运算只能在方法中进行
C：是普通方法，且没加{}
D：抽象方法不可以加{}

编程题

思路：
1.整体逆置
2.逐个单词逆置

边界条件：
1.当j走到最后一个单词如何处理
2.当逆置的单词只有一个时如何处理

易错点：
最后的输出格式是String类型，不能直接把数组toString，否则报错

import java.util.*;
public class Main {
    public static void reverse(char[] c,int left,int right){
        while(left<right){
            char tmp=c[left];
            c[left]=c[right];
            c[right]=tmp;
            left++;
            right--;
        }
    }

    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();
        //1.字符串整体逆置
        char[] c=s.toCharArray();
        int len=c.length;
        reverse(c,0,len-1);
        //2.对每个单词逆置
        //用于遍历数组
        int i=0;
        while(i<c.length){
            //易错点，每次逆置完一个单词一定要让j=i，否则j一直位于空格处死循环
            int j=i;
            while(j<c.length&&c[j]!=' '){
                j++;
            }
            //此时j索引一定位于空格处或者整个数组的length位置（数组的末尾）
            //所以有两种情况的处理
            if(j<c.length){
                reverse(c,i,j-1);
                i=j+1;
            }else{
                reverse(c,i,j-1);
                //退出循环的条件，此时j一定位于length
                i=j;
            }
        }
        String str=new String(c);
        System.out.println(str);
    }
}

import java.util.*;
public class Main {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        //防止数组越界，长度+1
        int[] data=new int[num+1];
        for(int i=0;i<num;i++){
            data[i]=sc.nextInt();
        }
        int count=0;
        int i=0;
        //遍历数组，可能出现三种情况
        //大于 等于 小于
        while(i<num){
            if(data[i]<data[i+1]){
                //可能出现前一个元素一直大于后一个元素
                //需要控制i的取值，防止越界
                while(i<num&&data[i]<data[i+1]){
                    i++;
                }
                //出现反例，子数组+1
                count++;
                i++;
            }else if(data[i]==data[i+1]){
                i++;
            }else{
                while(i<num&&data[i]>data[i+1]){
                    i++;
                }
                //同理，出现反例
                count++;
                i++;
            }
        }
        System.out.print(count);
    }
}