JAVA入门-018（修饰符）

包

包的概述和使用：

包，其实就是文件夹
作用就是对类进行分类管理

包的定义格式

• 格式：package 报名;(多级包用.分开)
• 范例：package com.Luli.Family;

带包的Java类编译和执行

• 手动建包
  按照以前的格式编译java文件 javac HelloWorld.java
  手动创建包 在D盘简历文件夹com，然后再com下建立文件夹Luli
  把class文件放到包的最里面
  带包执行 java com.Luli.HelloWorld

• 自动建包：
  javac -d.HelloWorld.java
  java com.Luli.HelloWorld

导包

导包的概述和使用：
代码测试：

package com.Luli.ImportTest.Test01;

public class Teacher {
    public void teach(){
        System.out.println("诲人不倦");
    }
}

package com.Luli.ImportTest.Test02.Demo;

public class Demo {
    Teacher teacher = new Teacher();
}

Demo生成Teacher对象时会报错，无法找到Teacher类。因为两个类并没有在同一个包里

第一种解决方案：

package com.Luli.ImportTest.Test02.Demo;

public class Demo {
    com.Luli.ImportTest.Test01.Teacher teacher = new com.Luli.ImportTest.Test01.Teacher();
}

这样子太不美观了
使用import：

package com.Luli.ImportTest.Test02.Demo;

import com.Luli.ImportTest.Test01.Teacher;

public class Demo {
    Teacher teacher = new Teacher();
}

使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了
为了简化包的操作，Java提供了导包的功能

导包的格式

• 格式：import 包名
• 范例：import com.Luli.ImportTest.Test01.Teacher;

修饰符

修饰符的分类

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

权限修饰符

代码测试：

package cn.Luli;

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 f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();

    }
}

运行结果：

在自己类中，四种修饰符的方法都能访问到。

同一个包下的子类集成的时候无法继承private修饰的方法

同一个包下直接创建对象无法访问到被private修饰的方法

不同包下的子类只能访问protected和public修饰的方法，不能访问private和默认修饰的方法

不同包下的无关类只能访问public类型的方法

状态修饰符

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

final

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

代码测试：

public class Fu {

    public int age=40;
    final public void  method(){        //final修饰的方法
        System.out.println("Fu method");
    }
}
/*
public final class Fu {                 //final修饰的类

    public int age = 40;

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

public class Zi extends Fu{
    public final int age = 20;          //final修饰的变量

    public void show(){
        //age=100;
        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修饰局部变量

代码测试：

public class Student {
    public int age = 30;
}

public class FinalDemo {
    public static void main(String[] args) {
        //final修饰基本类型变量
        final int age = 20;
        System.out.println(age);
       // age=100;                          被final修饰的变量成为了常量

        //final修饰引用类型的变量
        final Student s = new Student();
        s.age = 100;
        //s = new Student();                被final修饰的引用对象不能改变，但可以改变引用对象本身的值
        System.out.println(s.age);
    }
}

变量是基本类型：final修饰指的是基本类型的数据值不能发生改变
变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

static

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

代码测试：

public class Student {
    public String name;         //姓名
    public int age;             //年龄
    public static String university;   //学校 static表示共享
    
    public void show(){
        System.out.println("姓名："+name+"，年龄："+age+"，学校："+university);
    }
}

public class StaticDemo {
    public static void main(String[] args) {

        Student.university = "三国";	//推荐直接访问类的静态变量

        Student student = new Student();
        student.name= "大宝";
        student.age = 45;
        //student.university = "饭大吴疆土者，盛必吉尔破之"; 不推荐这样访问static
        student.show();

        Student s2 = new Student();
        s2.name = "吴懿";
        s2.age = 35;
        //s2.university = "吴懿不在此地，已遣别部出发";
        s2.show();
    }
}

运行结果：

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();                            //访问非静态成员方法
        show4();                            //访问静态成员方法
    }

    //静态成员方法    只能访问静态
    public static void show3(){
        //System.out.println(name);         //访问非静态成员变量 报错
        System.out.println(university);     //访问静态成员变量
        //show1();                          //访问非静态成员方法 报错
        show4();                            //访问静态成员方法
    }

    //静态成员方法
    public static void show4(){

    }
}

非静态的成员方法

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

静态的成员方法

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