【day008】Java学习，坚持就是胜利！

一、静态Static的内存图

package cn.itcast.day08.demo03;

public class Student {
    private int id; // 学号
    private String name; // 姓名
    private int age; // 年龄
    static String room; // 所在教室
    private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，计数器++

    public Student() {
        idCounter++;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    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 int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

package cn.itcast.day08.demo03;

public class Demo03StaticStudent {
    public static void main(String[] args) {
        // 首先设置一下教室，这是静态的东西，应该通过类名称进行调用
        Student.room = "101教室";

        Student one = new Student("郭靖", 20);
        System.out.println("one的姓名：" + one.getName());
        System.out.println("one的年龄：" + one.getAge());
        System.out.println("one的教室：" + Student.room);
        System.out.println("========================");

        Student two = new Student("黄蓉", 18);
        System.out.println("two的姓名：" + two.getName());
        System.out.println("two的年龄：" + two.getAge());
        System.out.println("two的教室：" + Student.room);
    }
}

二、静态代码块

package cn.itcast.day08.demo03;
/*
静态代码块的格式是：

public class 类名称 {
    static {
        // 静态代码块的内容
    }
}

特点：当第一次用到本类时，静态代码块执行唯一的一次。
*/
public class Person {
    static {
        System.out.println("静态代码执行！");
    }

    public Person() {
        System.out.println("构造方法执行！");
    }
}

package cn.itcast.day08.demo03;
/*
静态代码块的格式是：

public class 类名称 {
    static {
        // 静态代码块的内容
    }
}

特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值。
*/
public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

三、数组工具类Arrays

package cn.itcast.day08.demo04;

import java.util.Arrays;

/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

public static String toString(数组): 将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3...]）
public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。

备注：
1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。（今后学习）
*/
public class Demo01Arrays {
    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        // 将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); // [10, 20, 30]

        int[] array1 = {2, 1, 3, 10, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]

        String[] array2 = {"bbb", "aaa", "ccc"};
        Arrays.sort(array2);
//        System.out.println(Arrays.sort(array2));
        System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]

    }
}

四、Arrays练习：字符串倒序排列

package cn.itcast.day08.demo04;

import java.util.Arrays;

/*
题目：
请使用Arrays相关的API，将一个字符串中的所有字符升序排列，并倒序打印*/
public class Demo02ArraysPractise {
    public static void main(String[] args) {
        String str = "afjadfha324892na3j2";
        // 如何进行升序排列：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

package cn.itcast.day08.demo04;
/*
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

public static double abs(double num): 获取绝对值。有多种重载。
public static double ceil(double num): 向上取整。
public static double floor(double num): 向下取整。
public static long round(double num): 四舍五入。

Math.PI代表近似的圆周率常量（double)。
*/
public class Demo03Math {
    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("===========================");

        // 向上取整
        System.out.println(Math.ceil(3.9)); // 4.0
        System.out.println(Math.ceil(3.1)); // 4.0
        System.out.println(Math.ceil(3.0)); // 3.0
        System.out.println("============================");

        // 向下取整，抹零
        System.out.println(Math.floor(30.1)); // 30.0
        System.out.println(Math.floor(30.9)); // 30.0
        System.out.println(Math.floor(31.0)); // 31.0
        System.out.println("=============================");

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

六、Math练习：小学数学真题

package cn.itcast.day08.demo04;
/*
题目：
计算-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 Demo04MathPractise {
    public static void main(String[] args) {
        int count = 0; // 符合要求的数量
        double min = -10.8;
        double max = 5.9;
        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 + "个");
    }
}

七、继承的概念

八、继承的格式

package cn.itcast.day09.demo01;
/*
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。

定义父类的格式：（一个普通的类定义）
public class 父类名称 {
    // ...
}

定义子类的格式：
public class 子类名称 extends 父类名称 {
    // ...
}
*/
public class Demo01Extends {
    public static void main(String[] args) {
        // 创建一个子类对象
        Teacher teacher = new Teacher();
        // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
        teacher.method();

        // 创建另一个子类助教的对象
        Assistant assistant = new Assistant();
        assistant.method();
    }
}

package cn.itcast.day09.demo01;
// 定义一个父类：员工
public class Employee {
    public void method() {
        System.out.println("方法执行！");
    }
}

package cn.itcast.day09.demo01;
// 定义了一个员工子类：讲师
public class Teacher extends Employee{

}

package cn.itcast.day09.demo01;

public class Assistant extends Employee {
}

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

package cn.itcast.day09.demo02;
/*
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量：
    等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
    该方法属于谁，就优先用谁，没有则向上找。
*/
public class Demo01ExtendsField {
    public static void main(String[] args) {
        Fu fu = new Fu();
        System.out.println(fu.numFu); // 只能使用父类的东西，没有任何子类内容
        System.out.println("=======================");

        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
//        System.out.println(zi.abc); // 到处都没有，编译报错！
        System.out.println("========================");

        // 这个方法是子类的，优先用子类的，没有再向上找
        zi.methodZi(); // 200
        // 这个方法是在父类当中定义的
        zi.methodFu();




    }
}

package cn.itcast.day09.demo02;

public class Zi extends Fu{
    int numZi = 20;
    int num = 200;

    public void methodZi(){
        System.out.println(num);

    }
}

package cn.itcast.day09.demo02;

public class Fu {
    int numFu = 10;
    int num = 100;

    public void methodFu() {
        System.out.println(num);
    }
}

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

package cn.itcast.day09.demo03;
/*
局部变量：          直接写成员变量名
本类的成员变量：    this.成员变量名
父类的成员变量：    super.成员变量名
*/
public class Demo01ExtendsField {
    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.method();
    }
}

package cn.itcast.day09.demo03;

public class Fu {
    int num = 10;
}

package cn.itcast.day09.demo03;

public class Zi extends Fu{
    int num = 20;
    public void method() {
        int num = 30;
        System.out.println(num); // 30，局部变量
        System.out.println(this.num); // 20，本类的成员变量
        System.out.println(super.num); // 10，父类的成员变量
    }
}

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

package cn.itcast.day09.demo04;
/*
在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
    创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：
无论成员方法还是成员变量，如果没有都是向上找父类，绝不会向下找子类的。
*/
public class Demo01ExtendsMethod {
    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.methodFu();
        zi.methodZi();

        // 创建的是new了子类对象，所以优先用子类方法
        zi.method();
    }
}

package cn.itcast.day09.demo04;

public class Fu {
    public void methodFu() {
        System.out.println("父类方法执行！");
    }

    public void method() {
        System.out.println("父类重名方法执行！");
    }
}

package cn.itcast.day09.demo04;

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("子类方法执行！");
    }

    public void method() {
        System.out.println("子类重名方法执行！");
    }
}

十二、继承中方法的覆盖重写_概念与特点

十三、继承中方法的覆盖重写_注意事项

package cn.itcast.day09.demo05;

public class Fu {
    public String method() {
        return null;
    }
}

package cn.itcast.day09.demo05;

public class Zi extends Fu {
    @Override
    public String method() {
        return null;
    }
}

package cn.itcast.day09.demo05;
/*
方法覆盖重写的注意事项：

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
@Override: 写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的覆盖重写。

2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），
java.lang.String就算Object的子类。

3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。


*/
public class Demo01Override {
}

十四、继承中方法的覆盖重写_应用场景

package cn.itcast.day09.demo06;

public class Phone {
    public void call() {
        System.out.println("打电话");
    }

    public void send() {
        System.out.println("发短信");
    }

    public void show() {
        System.out.println("显示号码");
    }
}

package cn.itcast.day09.demo06;

// 定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone{
    @Override
    public void show() {
        super.show(); // 把父类的show方法拿过来重复利用
        // 自己子类再来添加更多内容
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

package cn.itcast.day09.demo06;

public class Demo01Phone {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();
        System.out.println("====================");

        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.send();
        newPhone.show();

    }
}

十五、继承中构造方法的访问特点

package cn.itcast.day09.demo07;

public class Fu {
    public Fu(int num) {
        System.out.println("父类构造方法！");
    }
}

package cn.itcast.day09.demo07;

public class Zi extends Fu{
    public Zi() {
//        super(); // 在调用父类无参构造方法
        super(20); // 在调用父类重载的参构造方法
        System.out.println("子类构造方法！");
    }

    public void method() {
//        super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。
    }
}

package cn.itcast.day09.demo07;
/*
继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super()”调用，所有一定是先调用的父类构造，后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。
*/

public class Demo01Constructor {
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}

十六、super关键字的三种用法

package cn.itcast.day09.demo08;

import java.security.PublicKey;

public class Fu {
    int num = 10;

    public void method() {
        System.out.println("父类方法");
    }
}

package cn.itcast.day09.demo08;
/*
1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造方法。
*/
public class Zi extends Fu{
    int num = 20;
    public Zi() {
        super(); // 3. 父类的构造方法
    }

    public void methodZi() {
        System.out.println(super.num); // 1.父类中的num
    }

    public void method() {
        super.method(); // 2. 访问父类中的method
        System.out.println("子类方法");
    }
}

十七、this关键字的三种用法

package cn.itcast.day09.demo09;

public class Fu {
    int num = 20;
}

package cn.itcast.day09.demo09;
/*
super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
在第三个用法中要注意：
A. this(...)调用也必须是构造方法的第一个语句，唯一一个。
B. super和this两种构造调用，不能同时使用。
*/
public class Zi extends Fu{
    int num = 20;

    public Zi() {
//        super(); // 这一行不再赠送
        this(123); // 本类的午参构造，调用本类的有参构造
//        this(1, 2); // 错误写法
    }

    public Zi(int n) {
        this(1, 2);
    }

    public Zi(int n, int m) {
//        this(); // 错误写法，调用循环了

    }

    public void shoNum() {
        int num = 10;
        System.out.println(num); // 局部变量
        System.out.println(this.num); // 本类中的成员变量
        System.out.println(super.num); // 父类中的成员变量
    }

    public void methodA() {
        System.out.println("AAA");

    }

    public void methodB() {
        // methodA(); // 也可以
        this.methodA(); // 代表本类中调用
        System.out.println("BBB");
    }
}

十八、super与this关键字图解

package cn.itcast.day09.demo10;

public class Fu {
    int num = 10;

    public void method() {
        System.out.println("父类方法");
    }
}

package cn.itcast.day09.demo10;

public class Zi extends Fu{
    int num = 20;

    @Override
    public void method() {
        super.method(); // 调用了父类方法
        System.out.println("子类方法");
    }

    public void show() {
        int num = 30;
        System.out.println(num); // 30
        System.out.println(this.num); // 20
        System.out.println(super.num); // 10
    }
}

package cn.itcast.day09.demo10;

public class Demo {
    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.show();
        zi.method();
    }
}

/*
30
20
10
父类方法
子类方法
*/

十九、Java继承的三个特点

二十、抽象的概念