面向对象高级(1)

今日指标：

• 可能晓得继承的益处和弊病
• 可能晓得继承中成员的拜访特点
• 可能晓得办法重写及利用
• 可能实现继承案例
• 可能晓得权限修饰符拜访特点
• 可能晓得 final 关键字润饰内容的特点
• 可能晓得 static 关键字润饰内容的特点

1：继承

1.1 面向对象高级课程安顿

来，持续啊，上面咱们持续来学习 Java 中十分重要的一个常识：面向对象高级局部。

而在解说面向对象高级内容之前呢，咱们先来回顾一下，后面学习过的面向对象基础知识。

在面向对象根底局部，咱们学习了：

• 类的定义
• 对象的应用
• private 关键字
• this 关键字
• 封装
• 构造方法
• JavaBean

过后的要求是可能编写一个规范的 JavaBean，也就是成员变量用 private 润饰，给出对应的 get/set 办法，以及给出一个无参构造方法。

为了让大家可能疾速的编写出这些代码，咱们还解说了如何疾速生成构造方法和 get/set 办法。

学完面向对象的基础知识后，咱们就能够本人设计一个类并进行应用了，基于这个根底上，咱们接着学习了 API 相干的常识。

次要学习了：

• Scanner
• Random
• GUI 体系的类(JLabel,JButton,JTextField,JTextArea 等)
• String
• 根本类型包装类
• Date
• SimpleDateFormat

而在应用 GUI 体系相干的类的应用，通过查看帮忙文档，咱们看到了一些过后无奈很好了解的常识：

这里波及到了父类和接口的常识，以及继承关系和实现关系。

再来看按钮的父类：AbstractButton

它其实是一个抽象类，这是就波及到了抽象类的常识。

并且，咱们还解说了对按钮增加事件的代码：

过后是让大家记住这个代码的格局，在办法体中写内容就能够了。为什么过后没有具体解说呢，因为这个代码中波及到了多态和匿名外部类相干的常识。

而咱们方才所提到的这些常识，等咱们学完了面向对象高级局部的常识后，大家就能够了解了。

最初，咱们来说一下面向对象高级这一块的课程安顿：

首先，咱们会解说继承，而后解说几种常见的修饰符，包含权限修饰符，最终态修饰符，动态修饰符。

接着，咱们会解说多态，抽象类，接口等高级常识，解说完这些内容后，大家就齐全能够把方才回顾过程中哪些不了解的常识搞明确了。

并且还可能看懂帮忙文档中任何一个 API 了。

最初，咱们还会解说一个小常识：外部类，在很多时候，它可能简化咱们代码的编写。

好了，到此对于面向对象高级这一块的课程安顿咱们就先讲到这里

1.2 继承概述

来，持续啊，上面咱们来学习继承。

在学习什么是继承前呢，咱们先看一个类，学生类，这个类大家并不生疏，蕴含两个属性和对应的 get,set 办法，另外还有一个学习的办法 study。

再来看一个类类，Teacher，成员变量是一样的，也给出了对应的 get/set 办法，只不过学习的办法没有了，改成了教学的办法 teach。

看完这两个类之后，咱们来看一下它们雷同的内容：

首先来说这两个成员变量，而成员变量也能够称为属性，所以咱们说这两个类有雷同的属性。

接着，咱们再来说成员变量对应的 get/set 办法，它们也是雷同的，所以咱们这两个类有雷同的办法。

而这些雷同的内容，咱们统称为雷同的特色。

如果咱们把雷同的特色给提取进去，这两个原始的类就会变成这个样子，来看一下，咱们把代码略微整顿一下，就会变成这个样子。

最初呢，咱们把雷同的特色也用一个类给示意进去，只不过这里咱们没有给出类名而已，而在这个不晓得名字的类中有两个成员变量和成员变量对应的 get/set 办法。

咱们再来看学生类和老师类，它们和原始的学生类和老师类示意的意思必定是不雷同的。

而在原始学生类和老师类中的成员变量和对应的 get/set 办法在这个不晓得名字的类中是存在的，那么，有没有一种机制，可能让学生类和老师类可能领有这个不晓得名字的类中的内容呢？

答案必定是有这种机制的。这种机制就是让他们之间产生一个关系，有了这个关系后，学生类和老师类中就能够领有这个不晓得名字的类中的内容了。

而这个关系就是咱们要解说的继承。来，咱们一起说一下：

• 继承是面向对象三大特色之一。(封装，继承，多态)
• 能够使得子类具备父类的属性和办法，还能够在子类中从新定义，追加属性和办法。

晓得了，什么是继承后，咱们来说一下，继承的格局：

继承的格局：

• 格局：public class 子类名 extends 父类名 {}
• 范例：public class Zi extends Fu {}
• Fu：是父类，也被称为基类、超类
• Zi：是子类，也被称为派生类

晓得了继承格局后，咱们到 IDEA 中去体验一下：

public class Fu {public void show() {System.out.println("show 办法被调用");
    }
}

public class Zi extends Fu {public void method() {System.out.println("method 办法被调用");
    }
}

/*
    测试类
 */
public class Demo {public static void main(String[] args) {
        // 创建对象，调用办法
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();}
}

代码演示结束后，回到材料再总结一下：

继承中子类的特点：

• 子类能够有父类的内容
• 子类还能够有本人特有的内容

好了，对于继承相干的基础知识咱们就先讲到这里。

解说结束后，大家赶快入手练习一下吧。

1.3 继承的益处和弊病

来，持续啊，上面咱们来学习继承的益处和弊病。

首先，咱们来说一下 继承的益处：

• 进步了代码的 <font color=’red’>复用性</font>(多个类雷同的成员能够放到同一个类中)
• 进步了代码的 <font color=’red’>维护性</font>(如果办法的代码须要批改，批改一处即可)

继承的第一个益处是进步了代码的复用性。怎么来了解呢，咱们来说一下：

多个类雷同的成员能够放到同一个类中，这一个类咱们就能够设计为父类，这多个类咱们就能够设计为子类。雷同的内容放到了父类中，咱们就能够简化这多个子类的代码，而雷同的代码就能够

被多个子类应用，未来再来一个子类的时候，它也能够通过继承领有父类的内容。所以，咱们说继承进步了代码的复用性。

继承的第二个益处是进步了代码的维护性。咱们也来说一下：

如果咱们有多个类，它们有雷同的办法，在应用继承之前，如果这个雷同的办法须要进行批改，那么咱们就须要批改多个类中的代码。而在应用继承后，因为咱们把雷同的代码提取到了父类中，

所以，在须要批改的时候，咱们只须要批改一处即可。所以，咱们说继承进步了代码的维护性。

这两个就是咱们要解说的继承的益处：进步了代码的复用性，进步了代码的维护性。

解说完继承的益处后，咱们来说一下 继承的弊病：

• 继承让类与类之间产生了关系，类的耦合性加强了，当父类发生变化时子类实现也不得不跟着变动，减弱了子类的独立性

所以，咱们说，在程序设计中，咱们要好好的思考该不该应用继承。

那么，咱们什么时候该应用继承呢？这里给大家解说一个最简略的准则。

来，咱们来说一下 什么时候应用继承：

• 继承体现的关系：<font color=’red’>is a</font>
• 假如法：我有两个类 A 和 B，如果他们满足 A 是 B 的一种，或者 B 是 A 的一种，就阐明他们存在继承关系，这个时候就能够思考应用继承来体现，否则就不能滥用继承
• 举例：苹果和水果，猫和动物，<font color=’red’>猫和狗</font>

要解说这个内容，咱们先要通知大家的是：继承体现的是 is a 的关系，也就是什么是什么的一种，咱们采纳假如法就能够用来判断两个类是否存在继承关系。

来，咱们举例说明一下：苹果和水果，因为苹果是水果的一种，所以，咱们能够把水果设计为父类，苹果设计为子类。

咱们再来说，猫和动物，因为猫是动物的一种，所以，咱们能够把动物设计为父类，猫设计为子类。

最初，咱们再来说猫和狗，猫是狗的一种，或者狗是猫的一种，这都说不通，所以，它们之间不存在继承关系，就不应该采纳继承关系来设计猫类和狗类。

好了，对于继承的益处和弊病，以及什么时候应用继承咱们就先讲到这里。

1.4 继承中成员拜访特点

1.4.1 成员变量拜访特点

来，持续啊，上面咱们来学习继承中成员变量的拜访特点。

而对于这个特点呢，咱们先到 IDEA 中去演示，而后再回来总结。

public class Fu {
    // 年龄
    public int age = 40;
}

public class Zi extends Fu {
    // 身高
    public int height = 175;

    // 年龄
    public int age = 20;

    public void show() {
        int age = 30;
        System.out.println(age);
        System.out.println(height);
        // 报错
//        System.out.println(weight);
    }
}

/*
    测试类
 */
public class Demo {public static void main(String[] args) {
        // 创建对象，调用办法
        Zi z = new Zi();
        z.show();}
}

这里为了拜访不便，年龄咱们用 public 进行了润饰。

演示结束后，回到材料咱们来总结一下：

在子类办法中拜访一个变量：

• 子类部分范畴找
• 子类成员范畴找
• 父类成员范畴找
• 如果都没有就报错(不思考父亲的父亲…)

好了，对于继承中成员变量的拜访特点咱们就先讲到这里

1.4.2 super 关键字

来，持续啊，上面咱们来学习 super 关键字。

而对于 super 关键字的学习，咱们先到 IDEA 中去演示，而后再回来总结。

public class Fu {public int age = 40;}

public class Zi extends Fu {
    public int age = 20;

    public void show() {
        int age = 30;
        System.out.println(age);
        // 我要拜访本类的成员变量 age，怎么办呢？System.out.println(this.age);
        // 我要拜访父类的成员变量 age，怎么办呢？System.out.println(super.age);
    }
}

/*
    测试类
 */
public class Demo {public static void main(String[] args) {
        // 创建对象，调用办法
        Zi z = new Zi();
        z.show();}
}

演示结束后，回到材料咱们来总结一下：

super 关键字的用法和 this 关键字的用法类似

• this：代表调用该办法的对象(个别咱们是在以后类中应用 this，所以咱们常说 this 代表本类对象的援用)
• super：代表父类存储空间的标识(能够了解为父类对象援用)
  

这里的拜访成员变量咱们方才曾经演示过了，至于拜访构造方法和拜访成员办法，咱们先理解格局，接下来咱们就会应用到。

好了，对于 super 关键字咱们就先讲到这里

解说结束后，大家赶快入手练习一下吧。

1.4.3 构造方法拜访特点

来，持续啊，上面咱们来学习继承中构造方法的拜访特点。

而对于这个特点呢，咱们先到 IDEA 中去演示，而后再回来总结。

public class Fu {public Fu() {System.out.println("Fu 中无参构造方法被调用");
    }

    public Fu(int age) {System.out.println("Fu 中带参构造方法被调用");
    }

}

public class Zi extends Fu {public Zi() {System.out.println("Zi 中无参构造方法被调用");
    }

    public Zi(int age) {System.out.println("Zi 中带参构造方法被调用");
    }

}

/*
    测试类
*/
public class Demo {public static void main(String[] args) {
        // 创建对象
        Zi z = new Zi();

        Zi z2 = new Zi(20);
    }
}

演示结束后，回到材料咱们来总结一下：

• 子类中所有的构造方法默认都会拜访父类中无参的构造方法
• 为什么呢？
• 因为子类会继承父类中的数据，可能还会应用父类的数据。所以，子类初始化之前，肯定要先实现父类数据的初始化
• 每一个子类构造方法的第一条语句默认都是：super()

这个时候，回到代码中咱们把 super 给加上，持续解说如果父类没有无参构造方法，该怎么办呢？

public class Fu {

    /*
    public Fu() {System.out.println("Fu 中无参构造方法被调用");
    }
    */

    public Fu() {}

    public Fu(int age) {System.out.println("Fu 中带参构造方法被调用");
    }

}

public class Zi extends Fu {public Zi() {//        super();
//        super(20);
        System.out.println("Zi 中无参构造方法被调用");
    }

    public Zi(int age) {//        super();
//        super(20);
        System.out.println("Zi 中带参构造方法被调用");
    }

}

/*
    测试类
*/
public class Demo {public static void main(String[] args) {
        // 创建对象
        Zi z = new Zi();

        Zi z2 = new Zi(20);
    }
}

演示结束后，回到材料咱们来总结一下：

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

① 通过应用 super 关键字去显示的调用父类的带参构造方法

② 在父类中本人提供一个无参构造方法

举荐：本人给出无参构造方法

好了，对于继承中构造方法的拜访特点咱们就先讲到这里。

解说结束后，大家赶快入手练习一下吧。

1.4.4 成员办法拜访特点

来，持续啊，上面咱们来学习继承中成员办法的拜访特点。

而对于这个特点呢，咱们先到 IDEA 中去演示，而后再回来总结。

public class Fu {public void show() {System.out.println("Fu 中 show()办法被调用");
    }

}

public class Zi extends Fu {public void method() {System.out.println("Zi 中 method()办法被调用");
    }

    public void show() {super.show();
        System.out.println("Zi 中 show()办法被调用");
    }
}

/*
    测试类
 */
public class Demo {public static void main(String[] args) {
        // 创建对象，调用办法
        Zi z = new Zi();
        z.method();
        z.show();
        // 报错
//        z.test();}
}

演示结束后，回到材料咱们来总结一下：

通过子类对象拜访一个办法：

• 子类成员范畴找
• 父类成员范畴找
• 如果都没有就报错(不思考父亲的父亲…)

好了，对于继承中成员办法的拜访特点咱们就先讲到这里。

解说结束后，大家赶快入手练习一下吧。

1.5 办法重写

来，持续啊，上面咱们来学习办法重写。

那 什么是办法重写呢？咱们一起来说一下：

• 子类中呈现了和父类中截然不同的办法申明

晓得了什么是办法重写后，那办法重写有什么用呢？这里咱们来说一下 办法重写的利用场景：

• 当子类须要父类的性能，而性能主体子类有本人特有内容时，能够重写父类中的办法，这样，即因循了父类的性能，又定义了子类特有的内容
• 练习：手机类和新手机类

上面呢，咱们通过一个练习，来解说一下办法重写的利用，这个练习是：手机类和新手机类。

来，咱们一起来写代码啊。

/*
    手机类
 */
public class Phone {public void call(String name) {System.out.println("给" + name + "打电话");
    }
}

/*
    新手机
 */
public class NewPhone extends Phone {

    /*
    public void call(String name) {System.out.println("开启视频性能");
//        System.out.println("给" + name + "打电话");
        super.call(name);
    }
    */

    @Override
    public void call(String name) {System.out.println("开启视频性能");
//        System.out.println("给" + name + "打电话");
        super.call(name);
    }

}

/*
    测试类
 */
public class PhoneDemo {public static void main(String[] args) {
        // 创建对象，调用办法
        Phone p = new Phone();
        p.call("林青霞");
        System.out.println("--------");

        NewPhone np = new NewPhone();
        np.call("林青霞");
    }
}

演示结束后，回到材料，咱们再来说一下，方才解说了一个小常识：

@Override：

• 是一个注解(注解前面会学习到)
• 能够帮忙咱们查看重写办法的办法申明的正确性

好了，对于办法重写咱们就先讲到这里。

解说结束后，大家赶快入手练习一下吧。

1.6 Java 中继承的注意事项

来，持续啊，上面咱们来学习 Java 中继承的注意事项。

而对于这个注意事项呢，咱们先到 IDEA 中去演示，而后再回来总结。

public class Granddad {public void drink() {System.out.println("爷爷爱喝酒");
    }

}

public class Father extends Granddad {public void smoke() {System.out.println("爸爸爱抽烟");
    }

}

public class Mother {public void dance() {System.out.println("妈妈爱跳舞");
    }

}

/*
public class Son extends Father, Mother {

}
*/

public class Son extends Father {}

演示结束后，回到材料咱们来总结一下：

• Java 中类只反对单继承，不反对多继承
• Java 中类反对多层继承
  

好了，对于 Java 中继承的注意事项咱们就先讲到这里。

1.7 继承案例

1.7.1 老师和学生

需要：定义老师类和学生类，而后写代码测试；最初找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的形式改写代码，并进行测试

看完需要后，咱们先简略的说一下思路：

思路：

①定义老师类(姓名，年龄，教书())

②定义学生类(姓名，年龄，学习())

③定义测试类，写代码测试

/*
    老师类
 */
public class Teacher {
    private String name;
    private int age;

    public Teacher() {}

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 void teach() {System.out.println("用爱成就每一位学员");
    }
}

/*
    学生类
 */
public class Student {
    private String name;
    private int age;

    public Student() {}

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

    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 void study() {System.out.println("好好学习天天向上");
    }
}

/*
    测试类
 */
public class Demo {public static void main(String[] args) {
        // 创立老师类对象进行测试
        Teacher t1 = new Teacher();
        t1.setName("林青霞");
        t1.setAge(30);
        System.out.println(t1.getName() + "," + t1.getAge());
        t1.teach();

        Teacher t2 = new Teacher("风清扬", 33);
        System.out.println(t2.getName() + "," + t2.getAge());
        t2.teach();

        // 学生类的测试，留给大家本人练习
    }
}

演示结束后，回到材料，持续说：

④共性抽取父类，定义人类(姓名，年龄)

⑤定义老师类，继承人类，并给出本人特有办法：教书()

⑥定义学生类，继承人类，并给出本人特有办法：学习()

⑦定义测试类，写代码测试

/*
    人类
 */
public class Person {
    private String name;
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 class Teacher extends Person {public Teacher() { }

    public Teacher(String name, int age) {
//        this.name = name;
//        this.age = age;
        super(name, age);
    }

    public void teach() {System.out.println("用爱成就每一位学员");
    }

}

/*
    测试类
 */
public class PersonDemo {public static void main(String[] args) {
        // 创立老师类对象并进行测试
        Teacher t1 = new Teacher();
        t1.setName("林青霞");
        t1.setAge(33);
        System.out.println(t1.getName() + "," + t1.getAge());
        t1.teach();


        Teacher t2 = new Teacher("风清扬", 36);
        System.out.println(t2.getName() + "," + t2.getAge());
        t2.teach();

        // 学生类的定义和测试，留给大家自学练习
    }
}

留给大家的作业：定义学生类继承自人类，并创立学生类对象进行测试。

好了，对于老师和学生的练习咱们就先讲到这里。

解说结束后，大家赶快入手练习一下吧。

1.7.2 项目经理和程序员

需要：请应用继承的思维设计出项目经理类和程序员类，并进行测试。

看完这个需要后，咱们首先得晓得项目经理和程序员都有哪些属性和行为，这样咱们才可能设计这两个类，通过这两个类的共性个性，设计出一个父类。

这里呢，咱们给出项目经理和程序员的成员变量和成员办法：

项目经理：

​ 成员变量：工号，姓名，工资，奖金

​ 成员办法：工作

程序员：

​ 成员变量：工号，姓名，工资

​ 成员办法：工作

通过剖析，咱们能够找到它们的共性内容，设计出一个父类：员工类

员工类：

​ 成员变量：工号，姓名，工资

​ 成员办法：工作

程序员类继承自员工类，没有新的成员须要增加。

而项目经理类继承自员工类，须要增加一个成员变量：奖金。

上面给出实现思路：

思路：

①定义员工类(工号，姓名，工资，工作())

②定义项目经理类，继承自员工类，增加一个新的成员变量奖金

③定义程序员类，不须要增加新的成员

④定义测试类，进行测试

剖析结束后，咱们到 IDEA 中去实现一下：

/*
    员工类
 */
public class Employee {
    // 工号
    private String id;
    // 姓名
    private String name;
    // 薪水
    private double salary;

    public Employee() {}

    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public String getId() {return id;}

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

    public String getName() {return name;}

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

    public double getSalary() {return salary;}

    public void setSalary(double salary) {this.salary = salary;}

    public void work() {System.out.println("员工须要工作");
    }
}

/*
    项目经理类
 */
public class Manager extends Employee {
    // 奖金
    private double bonus;

    public Manager() {}

    public Manager(String id, String name, double salary, double bonus) {super(id, name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {return bonus;}

    public void setBonus(double bonus) {this.bonus = bonus;}

    @Override
    public void work() {System.out.println("项目经理和客户谈需要");
    }
}

/*
    程序员类
 */
public class Programmer extends Employee {public Programmer() { }

    public Programmer(String id, String name, double salary) {super(id, name, salary);
    }

    @Override
    public void work() {System.out.println("程序员依据需要编写代码");
    }
}

/*
    测试类
 */
public class EmployeeDemo {public static void main(String[] args) {
        // 创立项目经理类对象，并进行测试
        Manager m1 = new Manager();
        m1.setId("itheima001");
        m1.setName("林青霞");
        m1.setSalary(10000.00);
        m1.setBonus(20000.00);
        System.out.println(m1.getId() + "," + m1.getName() + "," + m1.getSalary() + "," + m1.getBonus());

        Manager m2 = new Manager("itheima001", "林青霞", 10000.00, 20000.00);
        System.out.println(m2.getId() + "," + m2.getName() + "," + m2.getSalary() + "," + m2.getBonus());
        System.out.println("-------------------------------");

        // 创立程序员类对象，并进行测试
        Programmer p1 = new Programmer();
        p1.setId("itheima520");
        p1.setName("风清扬");
        p1.setSalary(20000.00);
        System.out.println(p1.getId() + "," + p1.getName() + "," + p1.getSalary());

        Programmer p2 = new Programmer("itheima520", "风清扬", 20000.00);
        System.out.println(p2.getId() + "," + p2.getName() + "," + p2.getSalary());
    }
}

重点看子类新增的成员变量如何赋值，以及重写父类办法后的调用。

好了，对于项目经理和程序员的练习咱们就先讲到这里。

解说结束后，大家赶快入手练习一下吧。

2：修饰符

2.1 权限修饰符

来，持续啊，上面咱们来学习修饰符。

在学习修饰符之前，咱们先说一下 修饰符的分类：

• 权限修饰符
• 状态修饰符

修饰符分为权限修饰符和状态修饰符，咱们先来学习权限修饰符。

而对于权限修饰符呢，咱们先到 IDEA 中去演示，而后再回来总结。

package com.itheima_01;

public class Fu {private void show1() {System.out.println("private");
    }

    void show2() {System.out.println("默认");
    }

    protected void show3() {System.out.println("protected");
    }

    public void show4() {System.out.println("public");
    }

    public static void main(String[] args) {
        // 创立 Fu 的对象，测试看有哪些办法能够应用
        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();}

}

package com.itheima_01;

public class Zi extends Fu {public static void main(String[] args) {
        // 创立 Zi 的对象，测试看有哪些办法能够应用
        Zi z = new Zi();
        z.show2();
        z.show3();
        z.show4();}

}

package com.itheima_01;

public class Demo {public static void main(String[] args) {
        // 创立 Fu 的对象，测试看有哪些办法能够应用
        Fu f = new Fu();
        f.show2();
        f.show3();
        f.show4();}

}

package com.itheima_02;

import com.itheima_01.Fu;

public class Zi extends Fu {public static void main(String[] args) {
        // 创立 Zi 的对象，测试看有哪些办法能够应用
        Zi z = new Zi();
        z.show3();
        z.show4();}

}

package com.itheima_02;

import com.itheima_01.Fu;

public class Demo {public static void main(String[] args) {
        // 创立 Fu 的对象，测试看有哪些办法能够应用
        Fu f = new Fu();
        f.show4();}

}

演示结束后，回到材料咱们来总结一下：

好了，对于权限修饰符咱们就先讲到这里

2.2 final

2.2.1 final 关键字

来，持续啊，上面咱们来学习状态修饰符。

在学习状态修饰符之前，咱们先说一下 状态修饰符的分类：

• final(最终态)
• static(动态)

状态修饰符分为 final 最终态和 static 动态，咱们先来学习 final 最终态。

而对于 final 最终态呢，咱们先来说一下：

• final 关键字是最终的意思，能够润饰成员办法，成员变量，类

那用 final 润饰的内容有什么特点呢？咱们先到 IDEA 中去演示，而后再回来总结。

public class Fu {public final void method() {System.out.println("Fu method");
    }

}

/*
public final class Fu {public final void method() {System.out.println("Fu method");
    }

}

*/

public class Zi extends Fu {

    public final int age = 20;

    public void show() {
//        age = 30;
        System.out.println(age);
    }


//    @Override
//    public void method() {//        System.out.println("Zi method");
//    }

}

/*
    测试类
 */
public class Demo {public static void main(String[] args) {Zi z = new Zi();
        z.method();
        z.show();}
}

演示结束后，回到材料咱们来总结一下：

final 润饰的特点

• 润饰办法：表明该办法是最终办法，不能被重写
• 润饰变量：表明该变量是常量，不能再次被赋值
• 润饰类：表明该类是最终类，不能被继承

好了，对于 final 关键字咱们就先讲到这里

2.2.2 final 润饰局部变量

来，持续啊，上面咱们来学习 final 润饰局部变量。

而对于 final 润饰局部变量呢，咱们先到 IDEA 中去演示，而后再回来总结。

public class Student {public int age = 20;}

/*
    测试类
 */
public class FinalDemo {public static void main(String[] args) {
        //final 润饰根本类型变量
        final int age = 20;
//        age = 100;
        System.out.println(age);


        //final 润饰援用类型变量
        final Student s = new Student();
        s.age = 100;
        System.out.println(s.age);

//        s = new Student();}

}

演示结束后，回到材料咱们来总结一下：

final 润饰局部变量：

• 变量是根本类型：final 润饰指的是根本类型的 数据值 不能产生扭转
• 变量是援用类型：final 润饰指的是援用类型的 地址值 不能产生扭转，然而地址外面的内容是能够产生扭转的

好了，对于 final 润饰局部变量咱们就先讲到这里

2.3 static

2.3.1 static 关键字

来，持续啊，上面咱们来学习 static 关键字。

首先，咱们来说一下：

• static关键字是动态的意思，能够润饰成员办法，成员变量

那用 static 润饰的成员有什么特点呢？咱们先到 IDEA 中去演示，而后再回来总结。

public class Student {

    public String name; // 姓名
    public int age; // 年龄
    //    public String university; // 学校
    public static String university; // 学校

    public void show() {System.out.println(name + "," + age + "," + university);
    }

}

/*
    测试类
 */
public class StaticDemo {public static void main(String[] args) {

        Student.university = "传智大学";

        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 33;
//        s1.university = "传智大学";
        s1.show();

        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 36;
//        s2.university = "传智大学";
        s2.show();}
}

演示结束后，回到材料咱们来总结一下：

static 润饰的特点

• 被类的所有对象共享，这也是咱们判断是否应用动态关键字的条件
• 能够通过类名调用，当然，也能够通过对象名调用，举荐应用类名调用

好了，对于 static 关键字咱们就先讲到这里

2.3.2 static 拜访特点

来，持续啊，上面咱们来学习 static 润饰成员的拜访特点。

那有什么特点呢？咱们先到 IDEA 中去演示，而后再回来总结。

/*
    static 拜访特点
 */
public class Student {
    // 非动态成员变量
    private String name = "林青霞";
    // 动态成员变量
    private static String university = "传智大学";

    // 非动态成员办法
    public void show1() {}

    // 非动态成员办法
    public void show2() {System.out.println(name);
        System.out.println(university);
        show1();
        show3();}

    // 动态成员办法
    public static void show3() {}

    // 动态成员办法
    public static void show4() {//        System.out.println(name);
        System.out.println(university);
//        show1();
        show3();}
}

演示结束后，回到材料咱们来总结一下：

非动态的成员办法

• 能拜访动态的成员变量
• 能拜访非动态的成员变量
• 能拜访动态的成员办法
• 能拜访非动态的成员办法

动态的成员办法

• 能拜访动态的成员变量
• 能拜访动态的成员办法

总结成一句话就是：动态成员办法只能拜访动态成员

好了，对于 static 润饰成员的拜访特点咱们就先讲到这里

2.3.3 main 办法具体阐明

来，持续啊，上面咱们来学习 main 办法的具体阐明。

首先，咱们来看一下，这是 main 办法的申明：

public static void main(String[] args) {}

• public 被 jvm 调用，拜访权限足够大
• static 被 jvm 调用，不必创建对象，间接类名拜访
• void 被 jvm 调用，不须要给 jvm 返回值
• main 一个通用的名称，尽管不是关键字，然而被 jvm 辨认
• String[] args 以前用于接管键盘录入的
• 演示 args 接收数据

IDEA 中代码演示：

public class HelloWorld {public static void main(String[] args) {System.out.println(args.length);

        for (int i = 0; i < args.length; i++) {System.out.println(args[i]);
        }
    }
}

通过 args 接收数据，参数的配置：

第一步：抉择 HelloWorld 上面的 Edit Configurations…

第二步：配置参数，数据之间用空格隔开

对于 args 接管参数，当初曾经很少应用了，咱们作为理解即可。

好了，对于 main 办法的具体阐明咱们就先讲到这里

2.3.4 static 利用：工具类

来，持续啊，上面咱们来学习 static 的利用。

static 的利用有很多，这里咱们解说其中的一个，就是 static 关键字在工具类中的应用。

而对于工具类的制作呢，上面咱们一起到 IDEA 中去演示，而后再回来总结工具类的特点。

/*
    工具类：构造方法公有
        成员动态润饰
 */
public class ArrayTool {

    // 构造方法公有
    private ArrayTool() {}

    public static int getMax(int[] arr) {int max = arr[0];

        for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];
            }
        }

        return max;
    }
}

public class ArrayDemo {public static void main(String[] args) {
        // 定义一个数组
        int[] arr = {12, 56, 78, 93, 40};

        // 需要：获取数组中最大值
//        int max = arr[0];
//
//        for (int i = 1; i < arr.length; i++) {//            if (arr[i] > max) {//                max = arr[i];
//            }
//        }

        // 创建对象调用
//        ArrayTool at = new ArrayTool();
//        int max = at.getMax(arr);

        // 调用类的静态方法
        int max = ArrayTool.getMax(arr);

        System.out.println("数组中最大值是：" + max);
    }
}

演示结束后，回到材料咱们来总结一下：

工具类的特点：

• 构造方法公有
• 成员用 static 润饰

好了，对于工具类的制作和应用咱们就先讲到这里

2.3.5 jar 包和帮忙文档

来，持续啊，上面咱们来学习 jar 包和帮忙文档。

首先，咱们来回顾一下，方才咱们写了一个工具类：ArrayTool，提供了获取数组最大值的办法。然而呢，这个工具类只能在咱们以后的模块中应用。

实际上只有是获取数组最大值，无论是哪个我的项目中，代码应该都是一样的，为了让咱们的工具类做到一次书写，屡次应用的成果，这个时候，咱们就须要通过 jar 包来实现。

那 jar 包是什么呢？

jar 包，也就是后缀名为.jar 的文件，也叫做 jar 文件。JAR 文件（Java 归档，英语：JavaARchive）是一种软件包文件格式，个别状况下 jar 文件中打包了多个 class 文件。

简略的了解：jar 包就是.class 文件的压缩包

晓得了 jar 是什么之后，那如何制作 jar 包呢？

在解说 jar 包的制作和应用前，咱们先说一下，接下来要解说的内容，步骤比拟多，不过大家不同放心，在咱们给出的笔记中都有具体的步骤纪录，大家不必放心记不住，照着咱们给出的笔记，

大家就能够本人实现 jar 包的制作和应用。

而后再回到 jar 包的制作。

第一步：把工具类的代码，独自写到一个模块中，并增加文档正文

/**
 * 这是对数组进行操作的工具类
 *
 * @author fqy
 * @version 1.0
 */
public class ArrayTool {

    // 构造方法公有
    private ArrayTool() {}

    /**
     * 获取数组中的最大值
     *
     * @param arr 参数是一个 int 数组
     * @return 返回数组中的最大值
     */
    public static int getMax(int[] arr) {int max = arr[0];

        for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];
            }
        }

        return max;
    }
}

第二步：通过 File 找到新建模块的地位

第三步：依照如下步骤抉择要制作 jar 包的模块

第四步：在弹出的窗体中，抉择要制作 jar 包的模块，最初点击 OK 按钮

第五步：在这个窗体中，能够批改 jar 包的寄存门路，最初点击 OK 按钮

第六步：抉择 Build 上面的 Build Artifacts…

第七步：在弹出的窗体中，抉择 Build 即可

第八步：到 jar 包的寄存门路下，就能够找到生成的 jar 包

到此，jar 包就制作实现了。这里，咱们能够通过解压软件去看看 jar 包外面的内容。

有了 jar 包当前，咱们又该如何应用 jar 包呢？

第一步：在要应用 jar 的模块下新建一个 lib 文件夹

第二步：把 jar 包复制到该文件夹下

第三步：通过 Add as Library… 将内部 jar 包增加到 IDEA 我的项目中

第四步：在弹出的窗口个中，抉择要应用 jar 包的模块，点击 OK 按钮

第五步：最初在咱们本人的类中应用工具类

到此，jar 包的制作和应用咱们就解说结束了。

好了，讲完了 jar 包的制作和应用后，这里咱们再提出一个问题，如果他人仅仅给了你一个 jar 包，你都不晓得这个 jar 包提供了哪些类，哪些办法。

你该如何应用呢？回忆一下，后面咱们在学习 JDK 提供的 API 的时候，咱们是不是参照了一个帮忙文档啊。

这里呢，咱们就带着大家制作一个本人的帮忙文档。

来，回来持续，咱们来制作帮忙文档。

第一步：抉择 Tools 上面的 Generate JavaDoc…

第二步：在弹出的窗体中，补充如下内容，并最终点击 OK 按钮

第三步：最终通过浏览器就可能看到生成的帮忙文档

看到这里，预计有同学就要想了，为什么和咱们应用的帮忙文档格局不一样呢？这里要跟大家说一下，咱们应用的帮忙文档是 chm 格局后果，咱们能够把网页模式的文档通过工具制作成 chm 格局。

有空大家本人百度实现即可。这里咱们就不在解说这个内容了。

而后，咱们再来看看本人制作的帮忙文档中的内容，看完后，咱们再去看后面应用过的帮忙文档，就晓得是怎么回事了。而且，在当前的开发中，如果咱们应用到了第三个的 jar 包，并且它也提供了

帮忙文档，那么咱们就能够依据帮忙文档来应用它所提供的 API 了。到此，帮忙文档的制作咱们就解说结束了。

最初，咱们来总结一下，方才解说了三个内容：

• jar 包的制作
• jar 包的应用
• 帮忙文档的制作

每一步的流程和细节，咱们在材料中都有具体的纪录，大家参照文档就能够本人实现。

好了，对于 jar 包的制作和应用，以及帮忙文档的制作咱们就先讲到这里

2.3.6 Math 类应用(自学)

来，持续啊，上面咱们来学习 Math 类的应用。

首先，咱们关上帮忙文档，来看一下 Math 类，它在 java.lang 包下，应用它是不须要导包的。

理解了 Math 相干的基础知识后，咱们去看一下它外面的办法。

往下看，这里没有构造方法，没有构造方法，它的成员咱们该如何应用呢？

这里咱们来看一下，发现它外面的成员都用 static 润饰了，能够通过类名间接拜访。

回到材料，总结一下：

• Math 类是：数学工具类，蕴含对数学运算的办法
• 帮忙文档中，没有看到构造方法，因为成员都用 static 润饰了，能够通过类名间接拜访

上面咱们到 IDEA 中去演示几个办法：

/*
    Math 类的应用
 */
public class MathDemo {public static void main(String[] args) {//public static int abs(int a): 返回 int 值的绝对值
        System.out.println(Math.abs(10));
        System.out.println(Math.abs(-10));
        System.out.println("-----------");

        //public static int max(int a, int b): 返回两个 int 值中较大的 int
        System.out.println(Math.max(10, 20));
        System.out.println("-----------");

        //public static double pow(double a, double b): 返回第一个参数的值，该值是第二个参数的幂
        System.out.println(Math.pow(2, 3));
        System.out.println("-----------");

        //public static long round(double a): 返回与参数最靠近的 long
        System.out.println(Math.round(15.4));
        System.out.println(Math.round(15.5));
    }
}