面向对象高级(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));    }}