java笔记

数组工具类Array

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。
​
public static String toString(数组)，将参数数组变成字符串(按照默认格式。[元素1，元素2，元素3...])public static void sort(数组)。按照默认升序(从小到大）对数组的元素进行排序。
​
备注:
​
1.如果是数值, sort默认按照升序从小到大
​
2如果是字符串,sort默认按照字母升序
​
3．如果是自定义的类型，那么这个自定义的类需要有comparabLe或者Comparator接口的支持。
public class Demo02 {
    public static void main(String[] args) {
        int[] intArray = {10,20,30};
        //将int[] 数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);
​
        int[] array1 = {6,64,21,545,26};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));
​
        String[] array2 = { "ccc","aaa","bbb"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }
}

Arrays练习

题目：请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
public class Demo03 {
    public static void main(String[] args) {
        String str = "djsabfk64sankalfggd";
        //如何进行升序排列: sort
        //必须是—个数组，才能用Arrays.sort方法
        //String -->数组，用toCharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对字符串进行升序排列
​
        //需要倒序遍历
        for (int i = chars.length-1; i >= 0; i--) {
          System.out.println(chars[i]);
        }
    }
}

数组工具类Math

java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
​
public static double abs( double num)。获取绝对值。有多种重载。
​
public static double ceil(double num):向上取整。
​
public static double fLoor( double num):向下取整。
​
purblic static Long round ( doubLe rum)。四舍五入。
public class Demo0 {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(7.6));
        System.out.println(Math.abs(0));
        System.out.println(Math.abs(-7.3));
        //向上取整。
        System.out.println(Math.ceil(9.5));
        System.out.println(Math.ceil(9.1));
        System.out.println(Math.ceil(9.0));
        //向下取整。
        System.out.println(Math.floor(6.4));
        System.out.println(Math.floor(6.8));
        System.out.println(Math.floor(6.1));
        //四舍五入
        System.out.println(Math.round(7.5));
        System.out.println(Math.round(7.1));
        System.out.println(Math.round(7.8));
​
    }
}·

Math练习

题目:
​
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个?
​
分析：
​
1．既然已经确定了范围，for循环
​
2．起点位置-10.8应该转换成为-10，两种办法。
​
•   2.1可以使用Math.ceil方法,向上(向正方向）取整
​
•   2.2强转成为int，自动舍弃所有小数位
​
3，每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的。
​
4、如何拿到绝对值。Math .abs方法。
​
5.一旦发现了一个数字，需要让计数器++进行统计。
​
备注。如果使用Math.ceil方法，-10.8可以变成-10.0。注意double也是可以进行++
public class Demo0 {
    public static void main(String[] args) {
        int count = 0;//符合要求的数量
        double min = -10.8;
        double max =  5.9;
        //这样处理，变量i接受区间之内所有的整数
        for(int i = (int) min ; i < max; i++){
            int abs =Math.abs(i);//绝对值
            if(abs > 6 || abs <2.1){
                System.out.println(i);
                count++;
            }
        }
        System.out.println("总共多少个："+count);
    }
}

继承

面向对象的三大特征：封装性、继承性、多态性。

继承是多态的前提，如果没有继承，就没有多态。

继承主要解决的问题就是：共性抽取。

父类也可以叫基类、超类

子类也可以叫派生类

继承关系当中的特点：

1.子类可以拥有父类的 ”内容“。

2.字类还可以拥有自己专有的内容。

继承的格式

定义父类的格式:(一个普通的类定义)

public class父类名称{

// ....

}

定义子类的格式：

public class 子类名称 extends 父类名称 {

// ...

}

继承中成员变量的访问特点

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，
​
访问有两种方式:
​
直接通过子类对象访问成员变量:
​
   等号左边是谁,就优先用谁,没有则向上找。
​
间接通过成员方法访问成员变量:
​
该方法属子谁，就优先用谁,没有则向上找。
public class Fu {
    int numFu = 10;
    int num = 100;
    public void methodFu(){
        System.out.println(num);
    }
}
=================================
public class Zi extends Fu {
    int numZi = 20;
    int num = 200;
    public void methodZi(){
        System.out.println(num);
    }
}
=================================
public class Demo04 {
    public static void main(String[] args) {
        Fu fu = new Fu();   //创建父类对象
        System.out.println(fu.numFu);//只能使用父类的东西，没有任何子类内容
        Zi zi = new Zi();
        System.out.println(zi.numFu);//10
        System.out.println(zi.numZi);//20
        System.out.println("============");
        //等号左边是谁，就优先使用谁
        System.out.println(zi.num);//200
        //这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi();//200
        //这个方法是在父类当中定义的
        zi.methodFu();//100
    }
}

区分子类方法中重名的三种变量

局部变量：       直接写成员变量
本类的成员变量：    this.成员变量名
父类的成员变量：    super.成员变量名
public class Fu {
    int num = 100;
}
=========================================
public class Zi extends Fu {
    int num = 200;
    public void methodZi(){
        int num = 300;
        System.out.println(num);//300 局部变量
        System.out.println(this.num);//200 本类的成员变量
        System.out.println(super.num);//100 父类的成员变量
    }
}
==========================================
public class Demo04 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.methodZi();
    }
}

继承中成员方法的访问特点

在父子类的继承关系当中，创建子类对象，访问成员方法的规则:
创建的对象是谁，就优先用谁，如果没有则向上找。
注意事项:
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。
public class Fu {
    public void methodFu() {
        System.out.println("父类方法执行！");
    }
    public void method() {
        System.out.println("父类重名方法执行！");
    }
}
===============================================
public class Zi extends Fu {
    public void methodZi(){
        System.out.println("子类方法执行！");
    }
    public void method(){
        System.out.println("子类重名方法执行！");
    }
}
================================================
public class Demo04 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.methodFu();//父类方法执行！
        zi.methodZi();//子类方法执行！
        //创建的是new了子类对象，所以优先使用子类方法
        zi.method();//子类重名方法执行！
    }
}
    

覆盖重写

重写(Override）的概念

概念：在继承关系当中，方法的名称一样，参数列表也一样。

重写(Override)：方法的名称一样，参数列表【也一样】。覆盖、重写。

重载(Overload): 方法的名称一样，参数列表【不一样】。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

方法覆盖重写的注意事项:

1．必须保证父子类之间方法的名称相同，参数列表也相同。

@Override:写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2．子类方法的返回值必须【小于等于】父类方法的返回值范围。

小扩展提示。java.Lang.object类是所有类的公共最高父类（祖宗类)，java.Lang . String就是object的子类。

3，子类方法的权限必须【大于等于】父类方法的权限 修饰符。

小扩展提示,public > protected > ( default) > private

备注：(default)不是关键字default，而是什么都不写，留空。 例如 int num = 20;

覆盖重写应用：

public class Fu {
    public void call() {
        System.out.println("打电话");
    }
    public void send() {
        System.out.println("发短信");
    }
    public void show() {
        System.out.println("显示号码");
    }
}
==================================================
public class Zi extends Fu {
    public void show() {
        super.show();//把父类的show方法拿过来重复利用
        //自己子类再来添加更多内容
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}
==================================================
public class Demo04 {
    public static void main(String[] args) {
        Fu fu = new Fu();
        fu.call();
        fu.send();
        fu.show();
        System.out.println("===================");
        Zi zi = new Zi();
        zi.call();
        zi.send();
        zi.show();
    }
}
运行结果：
    打电话
    发短信
    显示号码
===================
    打电话
    发短信
    显示号码
    显示姓名
    显示头像
​

父子类构造方法的访问特点:

1、子类构造方法当中有一个默认隐含的"“super()"调用，所以一定是先调用的父类构造，后执行的子类构造。
​
2、子类构造可以通过super关键字来调用父类重载构造。
​
3.super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
​
总结：
子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一个，还必须是第一个。
public class Fu {
    public  Fu() {
        System.out.println("父类无参构造方法执行！");
    }
    public Fu(int num) {
        System.out.println("父类有参构造方法执行！");
    }
}
==================================================
public class Zi extends Fu {
    public  Zi() {
        super();//在调用父类无参构造方法
        //super(10);//在调用父类重载的构造方法
        System.out.println("子类方法构造执行！");
    }
    public void method() {
 //       super(); //错误写法！只有子类构造方法，才能调用父类构造方法
    }
}
===================================================
public class Demo04 {
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}

super关键字的用法有三种:

1.在子类的成员方法中，访问父类的成员变量。

2.在子类的成员方法中，访问父类的成员方法。

3.在子类的构造方法中，访间父类的构造方法。

this关键字用来访间本类内容。用法也有三种:

1、在本类的成员方法中,访问本类的成员变量:

2．在本类的成员方法中,访问本类的另一个成员方法。

3、在本类的构造方法中,访问本类的另一个构造方法。

在第三种用法当中要注意:

A. this (...)调用也必须是构造方法的第一个语句，唯——个。

B. super和this两种构造调用，不能同时使用。

public class Fu {
    int num = 10;//父类的成员变量。
    public  Fu() {//父类的构造方法。
        System.out.println("父类无参构造方法执行！");
    }
    public void method() {//父类的成员方法
        System.out.println("父类方法");
    }
}
========================================
public class Zi extends Fu {
    int num = 20;
    public  Zi() {//3.在子类的构造方法中，访间父类的构造方法。
        super();
        //this(123)  this 访问本类的另一个构造方法
    }
   // public Zi(int n){
   // }
    public void methodZi() {//1.在子类的成员方法中，访问父类的成员变量。
        System.out.println(super.num);//父类中的num
        System.out.println(this.num);//本类中的num  this 访问本类的成员变量
    }
    public void method(){//2.在子类的成员方法中，访问父类的成员方法。
        super.method();
        System.out.println("子类方法");
    }
        public void methodA(){
        System.out.println("AAAA");
    }
    public void methodB(){
        this.methodA();// this  访问本类的另一个成员方法。
        System.out.println("BBBBB");
    }
}
​
========================================
public class Demo04 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.methodZi();
        zi.method();
    }
}