Arrays工具类||继承

Arrays常见操作

/*工具类，一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作
* public static String toString(数组）：将参数数组变成字符串[1,2,3]
* public static void sort(数组)：排序，默认升序*/

public class Arrays1 {
    public static void main(String[] args) {
        int[] intarray={1,2,3,4};
        System.out.println(intarray);//
        String intStr = Arrays.toString(intarray);
        System.out.println(intStr);//[1,2,3,4]

        int[] a1 = {2,13,41,32,2};
        Arrays.sort(a1);
        String intStr1 = Arrays.toString(a1);//[2, 2, 13, 32, 41]
        System.out.println(intStr1);
    }
}

将一个随机字符串中的所有字符升序排列，并倒序打印。

public class Arrays2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next();//键盘输入字符串
        char[] ch =str.toCharArray();// 该方法的作用是返回一个字符数组，该字符数组中存放了当前字符串中的所有字符
        Arrays.sort(ch);
        sortF(ch);
    }
    public static void sortF(char[] s){
        for (int i = s.length-1; i>=0; i--) {
            System.out.println(s[i]);
        }
    }
}

Math操作

public static double abs(double num):获取绝对值
public static double ceil(double num)：向上取整
public static double floor(double num):向下取整
Math.PI圆周率 常量

public class Math1 {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.14));//3.14
        System.out.println(Math.abs(0));//0
        System.out.println(Math.abs(-2.5));//2.5

        //向上取整
        System.out.println(Math.ceil(11));//11.0
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.ceil(-2.4));//-2.0

        //向下取整
        System.out.println(Math.floor(3.1));//3.0
        System.out.println(Math.floor(-3.1));//-4.0
        System.out.println(Math.floor(11));//11.0

        //四舍五入
        System.out.println(Math.round(20.4));//20
        System.out.println(Math.round(10.5));//11
    }
}

计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

public class MathPractice {
    public static void main(String[] args) {
        getSum(-10.8,5.9,6,2.1);
    }
    public static void getSum(double a,double b,int c,double d){
        int sum =0;
        for(int s=(int)a;s<=b;s++){//这里a是double，转成int型，方便计算整数
            if(Math.abs(s)>c||Math.abs(s)<d){
                sum=sum+1;
            }
        }
        System.out.println(sum);
    }
}

继承

Java语言是单继承的，一个子类只能有一个父类，但是可以多级继承A extends B，B extends C。

/*继承
* 父类、基类、超类
* 子类、派生类
* 子类可以拥有父类的内容还可以拥有自己的
* 在继承的关系中，子类就是父类，教师就是员工。*/

创建Employee类

public class Employee {
    private String name;
    private int age;
    int numFu =10;
    int num=2000;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public static void getSalary(){
        System.out.println("发工资");
    }
}

创建Teacher类

public class Teacher extends Employee{
    int numZi=20;
    public void print(){
        System.out.println(num);
    }
}

public class Extends {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        Employee e1= new Employee();

        e1.setAge(10);
        e1.setName("fang");
        t1.setAge(12);
        t1.setName("wen");
        
        System.out.println(t1.getAge());//12
        System.out.println(t1.getName());//wen
        System.out.println(e1.getAge());//10
        System.out.println(e1.getName());//fang
        System.out.println(t1.numFu);//10
        System.out.println(e1.numFu);//10
        System.out.println(t1.numZi);//20
        t1.print();//2000，继承父类的num
    }
}

/*区分子类中方法重名的三种
局部变量：  直接写成员变量名
本类的成员变量： this.成员变量名
父类的成员变量: super.成员变量名
* */

自己测试，快把自己绕晕了，刚学习正好看看自己的逻辑。

public class Extends1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
        z.method1(10);
        Zi z1 = new Zi();
        z1.method1(1);

    }
}
class Fu{
    int num = 10 ;
    public void method0(){
        System.out.println("父类的nethod");
    }
}
class Zi extends Fu{

    int num = 20;
    public void method0(){
        System.out.println("子类的method");
    }
    public void method(){
        int num = 30;
        System.out.println(num);//30 局部变量
        System.out.println(this.num);//20  this本类的num
        System.out.println(super.num);//10  super父类的num
        method0();//子类的method
        super.method0();//父类的nethod
        this.method1(20);//静态的直接访问
    }
    public static void method1(int ab){//非静态的，没有static修饰，需要创建对象才能访问
        Zi zi =new Zi();
        int a = zi.num;
        int c = ab;
        System.out.println(a);//20
        System.out.println(c);
    }
    public static void method2(int ab){//非静态的，没有static修饰，需要创建对象才能访问
        Zi zi =new Zi();
        int a = zi.num;
        int c = ab;
        System.out.println(a);//20
        System.out.println(c);//
        //method1(20);
        //zi.method();
    }
}

/*继承关系中，父子类构造方法的访问特点
*
* 1子类构造方法中有一个默认隐含的super（）调用
* 可以通过super关键字来子类构造调用父类重载构造super(arg);
* super的父类构造器调用，必须是子类构造方法中的第一个语句**/

public class Constractor {
    public static void main(String[] args) {
        Z1 z = new Z1();
        z.fun1();//子类中没有fun1（），继承父类的fun1（）；
    }
}
class F1{
    public F1(){
        System.out.println("父类的");
    }
    public F1(int num){
        System.out.println(num+"父类重载的构造方法");
    }
    public void fun1(){
        System.out.println("方法1");
    }
}
class Z1 extends  F1{
    public Z1(){
        //super();//在调用父类的无参构造方法
        super(10);//10父类重载的构造方法
        System.out.println("子类的");
        //super();//必须放在第一个语句，只能调用一个构造方法
        super.fun1();//方法1
    }
}