面向对象笔记02-修饰符

面对对象高级01-修饰符

• 继承(重点)
• final 关键字(重点)
• static 关键字(重点)
• 工具类 思想(了解)

二、修饰符

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

2.1 权限修饰符

问题导入：游客、会员、SVIP

问题导入：类资源访问权限问题？

权限修饰符作用范围：

演示

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");
    }
    //1.同一个类中、都能用
    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 {
	//2.2.同一个包中子无关类  private不能用了
    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) {
        //2.2.同一个包中子无关类  private不能用了
        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) {
        //3.不同包的子类
        //创建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();
    }

}

总结：

private - 私有的成员变量

默认的在类中一般不常用，在接口中常用。

protected不常用。

public - 最常用！

2.2 状态修饰符

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

2.2.1 final关键字

final 关键字是最终的意思，可以修饰成员方法，成员变量，类，也可以修饰局部变量

final 修饰的特点

• 修饰方法：表明该方法是最终方法，不能被重写
• 修饰变量：表明该变量是常量，不能再次被赋值
• 修饰类：表明该类是最终类，不能被继承
• final修饰局部变量：
  • 变量是基本类型：final 修饰指的是基本类型的数据值不能发生改变
  • 变量是引用类型：final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

//3. final修饰类，该类不可被继承
//public final class Fu {
public class Fu {
//    1.final修饰成员方法。子类重写报错！
//    public final void method() {
    public void method() {
        System.out.println("Fu method");
    }
}

public class Zi extends Fu{
//    2. final修饰变量   再次修改值报错！
//    public final int age = 20;
    public 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修饰局部变量

public class Student {
    public int age = 10;
    //思考题？这个name可以修改吗？
    public final String name = "are you ok!";
}
/*
    测试类
 */
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;
//      s.name="uuuuu"
        System.out.println(s.age);
        System.out.println(s.name);
//      final 修饰指的是引用类型的**地址值**不能发生改变，但是地址里面的内容是可以发生改变的
        System.out.println(s);
//      s = new Student();
    }
}

优点：

• final关键字提高了性能。JVM和Java应用都会缓存final变量。
• final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。
• 使用final关键字，JVM会对方法、变量及类进行优化。
• 不可变类创建不可变类要使用final关键字。不可变类是指它的对象一旦被创建了就不能被更改了。String是不可变类的代表。不可变类有很多好处，譬如它们的对象是只读的，可以在多线程环境下安全的共享，不用额外的同步开销等等。

应用场景：

• Java中String、Integer类都是final类。
• 不修改经常改动的常量：连接数据库的Driver、url、password、username等。
• 常用的参数：π、重力加速度等。

总结：

一句话总结final:类、方法、变量都看修饰，一旦修饰，值、方法或者地址不可改变！

2.2.2 static关键字

static关键字是静态的意思，可以修饰成员方法，成员变量。

static 修饰的特点

• 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
• 可以通过类名调用，当然，也可以通过对象名调用，推荐使用类名调用

2.2.2.1演示1

public class Person {
    public String name = "";
//    static修饰成员变量
    public static String country;

    public void show1(){
        System.out.println("name="+name+",country="+country);
    }
}

// 测试
public class DomeStatic {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "张三";
        p1.country = "中国";
        p1.show1();

        Person p2 = new Person();
        p2.name = "李四";
//        p2.country = "中国";
        p2.show1();
    }
}

2.2.2.2探讨问题2：

public String country = “中国”;  
public static String country = “中国”; 
这两种不一样吗？为什么静态修饰可以通过类名直接调用？

不一样的。

根本原因是不同的！(下图)

探讨问题3：

不创建对象，通过类名直接访问show1方法。如何做到？

2.2.2.3static访问特点

/*
    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();
    }
}

结论：

非静态的成员方法

• 能访问静态的成员变量
• 能访问非静态的成员变量
• 能访问静态的成员方法
• 能访问非静态的成员方法

静态的成员方法

• 能访问静态的成员变量
• 能访问静态的成员方法

总结成一句话就是：静态成员方法只能访问静态成员

2.2.2.4应用场景

简化开发！提高内存使用效率！减少非核心代码new!

1. 工具类。md5加密工具类，数据库连接工具类等
2. 工厂类。mybatis工厂类等。

3. 1. 创建工具类
   2. 创建静态工具方法，参数为数组类型，返回值为int类型
   3. 业务逻辑
   4. 调用工具类测试

案例代码：制作一个工具类:获取数组中的最大值！

package day01.class08;

public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int []arr ={12,56,78,93,40};
        //需求：获取数组中最大值

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

  //          }

  //      }
        //通过创建对象调用,私有后不能进行调用
        //ArrayTool at = new ArrayTool();
       // int max = at.getMax(arr);
        //通过类名调用
        int max1 = ArrayTool.getMax(arr);
       // System.out.println("数组中最大值是："+max);
        System.out.println("数组中最大值是："+max1);
    }
}

package day01.class08;

public class ArrayTool {

    //外界不能使用构造方法，不可以创建对象调用，只能通过类名调用

    private ArrayTool(){}
    public static int getMax(int[] arr){


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

            }

        }
        return max;
    }
}

2.3.3 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接收参数，现在已经很少使用了。

三、jar包

• jar包：也就是后缀名为.jar 的文件，也叫做jar文件
• JAR文件（Java归档，英语：JavaARchive）是一种软件包文件格式，一般情况下jar文件中打包了多个class文件
• 简单的理解：jar包就是.class文件的压缩包

3.1 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包里面的内容。

3.2 jar包的使用

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

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

第三步：通过Add as Library…将外部jar包添加到IDEA项目中

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

第五步：最后在我们自己的类中使用工具类

3.3 帮助文档的制作

第一步：选择Tools下面的Generate JavaDoc…

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

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