考核11.11

杨辉三角

import java.util.Scanner;

public class Question3 {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        System.out.print("请输入层数：");
        int layer = sc.nextInt();
        int[][]triangle=new int[layer][layer];
        for (int i = 0; i <triangle.length ; i++) {
            for (int j = 0; j <=i ; j++) {
                if(j==0||i==j){
                    triangle[i][j] = 1;
                }else{
                    triangle[i][j]=triangle[i-1][j-1]+triangle[i-1][j];
                }
                System.out.print(triangle[i][j]+" ");
            }
            System.out.println();
        }
    }
}

public abstract class Vehicle {

        private String brand;
        public abstract void start();

        public void stop(){

        }

    public Vehicle(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

public interface Convertible {
    public void openRoof();
    public void closeRoof();

}

public class Car extends Vehicle implements Convertible{
    private boolean roofStatus=false;

    public Car(String brand){
        super(brand);
    }


    @Override
    public void openRoof() {
        if(roofStatus==true){
            System.out.println("车顶已打开，请勿重复操作");
        }else{
            roofStatus=true;
            System.out.println("成功打开车顶");
        }
    }

    @Override
    public void closeRoof() {
        if(roofStatus==true){
            System.out.println("车顶已关闭，请勿重复操作");
        }else{
            roofStatus=true;
            System.out.println("成功关闭车顶");
        }

    }

    @Override
    public void start() {
        System.out.println(super.getBrand()+"启动成功");

    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("奔驰");
        car.start();
        car.openRoof();
        car.openRoof();
        car.closeRoof();
        car.closeRoof();
        car.stop();
    }
}

import java.util.Scanner;

public class Question2 {
    public static void main(String[] args) {
        //字符统计
        int englishCount=0;
        int spaceCount=0;
        int numCount=0;
        int otherCount=0;
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine();

        for (int i = 0; i < str.length() ; i++) {
            char c=str.charAt(i);
            if(c>='a'&&c<='z'){
                englishCount++;
            }
            else if(c>='0'&&c<='9'){
                numCount++;
            }
            else if(c==' '){
                spaceCount++;
            }
            else{
                otherCount++;
            }
        }
        System.out.println("字母个数:"+englishCount);
        System.out.println("数字个数:"+numCount);
        System.out.println("空格个数:"+spaceCount);
        System.out.println("其它字符个数:"+otherCount);
    }
}

import java.util.Scanner;

public class Question1 {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入数字：");
        int m =sc.nextInt();
        boolean istrue = istrue(m);
        if(istrue){
            System.out.println("Yes");
        }else{
            System.out.println("No");
        }
    }

    public static boolean istrue(int x) {
        if(x==2){
            return true;
        }else{
            for (int i = 2; i <=2147483647 ; i++) {
                if(x%i==0){
                    return false;
                }
            }
            return true;
        }
    }

}

 java 普通类和抽象类有哪些区别

• 普通类不能包含抽象方法，抽象类可以包含抽象方法。
• 抽象类不能直接实例化，普通类可以直接实例化。

java中Break,Continue,Return的区别及作用

• break跳出总上一层循环，不再执行循环（结束当前的循环体）
• continue跳出本次循环，继续执行下次循环（结束正在执行的循环体，进入下一个循环条件）
• return程序返回，不再执行下面的代码（结束当前的方法，直接返回）

接口中可以定义静态方法（jdk8开始）；

在抽象类中可以有构造方法，只是不能直接创建抽象类的实例对象，但实例化子类的时候，就会初始化父类，不管父类是不是抽象类都会调用父类的构造方法 ，初始化一个类，先初始化父类；

全局变量可以直接被static、final同时修饰。

java 成员变量与局部变量的区别

1. 从语法上看，成员变量是属于类的局部变量是在方法中定义的变量或是方法的参数；成员变量可以被public、private、static等修饰符所修饰，而局部变量则不能被访问控制修饰符及static 所修饰；成员变量和局部变量都可以被final所修饰。
2. 从变量在内存中的存储方式来看，成员变量是对象的一部分，而对象是存在于对内存的，局部变量是存在于栈内存的。
3. 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而产生，随着方法调用的结束而自动消失。
4. 成员变量如果没有被赋初值，则会自动以类型的默认值赋值（有一种情况例外，被final修饰但没有被static修饰的成员变量必须显示的赋值）；而局部变量则不会自动赋值，必须显示的赋值后才能使用。

方法重载

1. 方法重载发生在一个类的内部，分为普通方法重载和构造方法重载。
2. 方法名称必须相同
3. 方法的参数个数、顺序、类型都不同
4. 与方法的返回值无关
5. 与方法的修饰符无关