强化训练48天-day06

目录

day01_0418

选择题 

day02_0419

选择题

day03_0420

选择题

day04_0421

选择题

编程题

day05_0422

选择题

编程

day06_0423

选择题

编程

---

day01_0418 选择题 

day02_0419 选择题

day03_0420 选择题

 实例方法与类方法的区别：前者无static，必须创建对象才能用

超类就是父类。

向上转型

父类名称  父类引用=new  子类名称（）

这里Person类中的name已经私有化了 

day04_0421 选择题

 

public可以作用于类，表示该类是公开类，此时包名必须和类名相同
abstract作用于类，表示该类是抽象类，不可被实例化
final作用于类，表示该类无法被继承，例如java.lang.String类就是final修饰的
void作用于方法，表示该方法无返回值，不可以作用于类

1.abstract类中可以有abstract方法
 abstract类中可以有abstract方法，也可以有非abstract方法
 非abstract类中不可以有abstract方法

2.abstract类不能使用new运算符创建对象

但是如果一个非抽象类是抽象类的子类，这时候我们想要创建该对象呢，这时候它就必须要重写父类的抽象方法，并且给出方法体，这也就是说明了为什么不允许使用final和abstract同时修饰一个类或者方法的原因。

 abstract的意义是为了让子类实现方法而存在，而final的意义是不让子类进行修改,它们是处于一个互斥的意义。

 java中不能用关键字起名

接口只能被public修饰，接口中绝对不能有private

interface是面向对象编程语言中接口 *** 作的关键字，功能是把所需成员组合起来，用来封装一定功能的集合。它好比一个模板，在其中定义了对象必须实现的成员，通过类或结构来实现它。接口不能直接实例化，即ICount ic=new iCount()是错的。接口不能包含成员的任何代码，只定义成员本身。接口成员的具体代码由实现接口的类提供。接口使用interface关键字进行声明。

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set

 在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于 *** 作所有的单列集合。

编程题

计算糖果

 

import java.util.Scanner;

/**
 * @editor biubiubiu
 */
public class Main {
    public static void main(String[] args) {
        Scanner sca=new Scanner(System.in);
        int[] arr=new int[4];
        for (int i = 0; i <4 ; i++) {
            arr[i]=sca.nextInt();//arr[0]=A-B;arr[1]=B-C;arr[2]=A+B;arr[3]=B+C;
        }
        int A=0;
        int B=0;
        int C=0;
        A=(arr[0]+arr[2])/2;
        B=(arr[1]+arr[3])/2;
        C=B-arr[1];
        int count=(arr[0]+arr[1]+arr[2]+arr[3])/2;
        if((arr[0]+arr[2])%2==0 && (arr[1]+arr[3])%2==0 && A+B==count &&  A-B==arr[0]){
            System.out.println(A+" "+B+" "+C);
        }else {
            System.out.println("No");
        }
    }
}

进制转换：给一个十位数M，转换成N进制（2<=N>=16）。

import java.util.Scanner;

/**进制转换(考虑负数，9以上用A，B,C等表示)
 * @editor biubiubiu
 */
public class ConwersionNumber {
    public static void main(String[] args) {
        Scanner sca=new Scanner(System.in);
        int M=sca.nextInt();
        int N=sca.nextInt();
        System.out.println(number(M,N));
    }
    public static String number(int M,int N){
        String s="";
        int m=0;
        boolean isNum=false;
        if(M==0){
            return s="0";
        }
     if (M<0){
         M=-M;
         isNum=true;
     }
     while(M!=0){
         m=M%N;
         if (m>9){
             char c=(char)(m+55);
             s=c+s;
         }else {
             s=m+s;
         }
         M=M/N;
     }
     if (isNum){
         s="-"+s;
     }
        return s;
    }

}

day05_0422 选择题

 void属于Java中的关键字

1.Java标识符只能由数字、字母、下划线“_”或“$”符号以及Unicode字符集组成
2.Java标识符必须以字母、下划线“_”或“$”符号以及Unicode字符集开头
3.Java标识符不可以是Java关键字、保留字（const、goto）和字面量（true、false、null）
4.Java标识符区分大小写，是大小写敏感的

 1.finally代码块的语句在return之前一定会得到执行
2.如果try块中有return语句，finally代码块没有return语句，那么try块中的return语句在返回之前会先将要返回的值保存，之后执行finally代码块，最后将保存的返回值返回，finally代码块虽然对返回值进行修改也不影响返回值，因为要返回的值在执行finally代码块之前已经保存了，最终返回的是保存的旧值（值传递）。
3.如果try块和finally块都有返回语句，那么虽然try块中返回值在执行finally代码块之前被保存了，但是最终执行的是finally代码块的return语句，try块中的return语句不再执行。
4.catch块和try块类似，会在执行finally代码块执行前保存返回值的结果，finally语句中有return语句则执行finally的return语句，没有则执行catch块中的return语句，返回之前的保存值。

 throw

用于方法块里面的 代码，比throws的层次要低，比如try…catch …语句块，表示它抛出异常，但它不会处理它。
final
用于类 ---- 说明该类无法被继承，实例：String类
用于方法-----说明该方法无法被覆盖，实例：final不能与abstract关键字同时使用
final用于变量-----说明属性不可变（可用于静态和非静态属性），但多和staic连用，表示常量
 

编程

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] arr=new int[n];
      for (int i = 0; i < n; i++) {
            arr[i]=sc.nextInt();
        }
       int Max=arr[0];
        int num=arr[0];
        for (int i = 1; i < arr.length; i++) {

             if(num<0){
                  num=arr[i];
              }else {
                  num+=arr[i];
              }
            if(Max

public class Palindrome {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String A=sc.nextLine();
        String B=sc.nextLine();
        int count=0;
        for (int i = 0; i <= A.length(); i++) {
            StringBuilder str=new StringBuilder(A);//存放A字符串
            str=str.insert(i,B);//将B字符串插入到A字符串的i位置
            StringBuilder temp=new StringBuilder(str);//存放插入后的str字符串
            temp=temp.reverse();//翻转插入后的str字符串
            if(str.toString().equals(temp.toString())){
                count++;
            }
        }
        System.out.println(count);
    }
}

注：B字符串可以加到A字符串末尾所以i可以取到A.length（）。

day06_0423 选择题

	范围	private	default	protected	public
1	同一个包中的同一个类	√	√	√	√
2	同一个包中的不同类		√	√	√
3	不同包中的子类			√	√
5	不同包中的非子类				√

1.最终类就是被final修饰的类，最终方法就是被final修饰的方法，最终类不能被继承，最终方法不能被重写

2.抽象类和最终类都可以被声明使用，抽象类不能被实例化，因为实例化必须加载类，但是不知道抽象方法体的大小，所以不能实例化

3.抽象类中可以有抽象方法，也可以没有抽象方法，

4.抽象类可以被继承，

5.继承抽象类，若有抽象方法，则子类必须将其抽象方法实现，

6.抽象方法中的非抽象方法可以被重写

7.加上final的类是最终类，加上final的方法就是最终方法，

8.最终类不能拥有子类，最终方法不能被重写

 static{}

静态代码块：当类加载时执行一次，与对象无关

当有继承关系时，先执行父类静态代码块，再执行子类静态代码块。

  1.finally代码块的语句在return之前一定会得到执行
2.如果try块中有return语句，finally代码块没有return语句，那么try块中的return语句在返回之前会先将要返回的值保存，之后执行finally代码块，最后将保存的返回值返回，finally代码块虽然对返回值进行修改也不影响返回值，因为要返回的值在执行finally代码块之前已经保存了，最终返回的是保存的旧值（值传递）。
3.如果try块和finally块都有返回语句，那么虽然try块中返回值在执行finally代码块之前被保存了，但是最终执行的是finally代码块的return语句，try块中的return语句不再执行。
4.catch块和try块类似，会在执行finally代码块执行前保存返回值的结果，finally语句中有return语句则执行finally的return语句，没有则执行catch块中的return语句，返回之前的保存值。

编程

 算数平方根——注意审题

 根据题意可以知道蛋糕应该像图中阴影部分这样

import java.util.Scanner;

/**
 * @editor biubiubiu
 */
public class cakeSum {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int W = sc.nextInt();
        int H = sc.nextInt();
        int[][] arr = new int[W][H];
        int count = 0;
        for (int i = 0; i < W; i++) {
            for (int j = 0; j < H; j++) {
                if (i % 4 == 0 || i % 4 == 1) {
                    if (j % 4 == 0 || j % 4 == 1) {
                        count++;
                    }
                } else {
                    if (j % 4 == 2 || j % 4 == 3) {
                        count++;
                    }
                }
            }
        }
        System.out.println(count);
    }
}

 注意：判空

           当只输入一个“+”或“-”时输出也为0；

           当输出应该为一个负数时，“-”不能省略

 

public class Solution {
    public int StrToInt(String str) {
       if (str.length()==0){
            return 0;
        }
        String s="";
         if(str.length()==1&&(str.charAt(0)>57||str.charAt(0)<48)){
            return 0;
        }
        for (int i = 0; i 47&&str.charAt(i)<58){
                s+=str.charAt(i);
            }else {
                if (str.charAt(i)!='+'&&str.charAt(i)!='-'){
                    return 0;
                }else {
                  if(str.charAt(i)=='+'){
                        continue;
                    }
                    s+=str.charAt(i);
                }
            }
        }
        return Integer.parseInt(s);
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/727054.html