java面向对象进阶-包、权限修饰符、final

1.包

1.1.什么是包？

1、包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。
2、建包的语法格式：package 公司域名倒写.技术名称。报名建议全部英文小写，且具备意义
3、建包语句必须在第一行， 一般IDEA工具会帮助创建

示例：

package com.TianchunGu.d1_package.it;

public class Student {

}

1.2.导包：

1、相同包下的类可以直接访问， 不同包下的类必须导包,才可以使用！
2、导包格式： import 包名.类名;
3、假如一个类中需要用到不同类， 而这个两个类的名称是一样的， 那么默认只能导入一个类， 另一个类要带包名访问。

package com.TianchunGu.d1_package;
//导包
import com.TianchunGu.d1_package.it.Student;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //目标：理解以下两点
        //1、同一个包下的类，相互可以直接访问
        System.out.println(User.onLineNumber);
        //2、不同包下的类，必须先导包才可以访问
        Student s = new Student();
        Scanner sc = new Scanner(System.in);
        //3、如果这个类中使用不同包下的相同类名，此时默认只能导入一个类的包，另一个类要使用全名访问
        com.TianchunGu.d1_package.it2.Student s2 = new com.TianchunGu.d1_package.it2.Student();
    }
}

1.3.在IDEA中设置自动导包

将以上设置完成后，就可以自动导包啦！！！

2.权限修饰符

2.1.什么是权限修饰符？

权限修饰符： 是用来控制一个成员能够被访问的范围的。
可以修饰成员变量， 方法， 构造器， 内部类， 不同权限修饰符修饰的成员能够被访问的范围将受到限制。

2.2.权限修饰符的分类和具体作用范围：

权限修饰符： 有四种作用范围由小到大（ private -> 缺省 -> protected - > public ）

示例一：

itcast.Fu

package com.TianchunGu.d2_modifier.itcast;

public class Fu {
    //1、private只能本类中访问
    private void show1(){
        System.out.println("private");
    }
    //2、缺省：本类、同一个包下的类中
    void show2(){
        System.out.println("缺省");
    }
    //3、protected:本类，同一个包下的类中，其他包下的子类
    protected void show3(){
        System.out.println("protected");
    }
    //4、任何地方都可以
    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();

    }
}

itcast.Demo

package com.TianchunGu.d2_modifier.itcast;

public class Demo {
    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可用
        Fu f = new Fu();
        //f.show1();//报错,私有的
        f.show2();
        f.show3();
        f.show4();
    }
}

示例二：
itheima.Zi

package com.TianchunGu.d2_modifier.itheima;

import com.TianchunGu.d2_modifier.itcast.Fu;

public class Zi extends Fu {
    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Zi z = new Zi();
        z.show3();
        z.show4();
    }
}

itheima.Demo

package com.TianchunGu.d2_modifier.itheima;

import com.TianchunGu.d2_modifier.itcast.Fu;

public class Demo {
    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show4();
    }
}

2.3.学完权限修饰符需要具备如下能力

能够识别别人定义的成员的访问权限。

自己定义成员（ 方法， 成员变量， 构造器等） 一般满足如下要求：

1.成员变量一般私有。
2.方法一般公开。
3.如果该成员只希望本类访问， 使用private修饰。
4.如果该成员只希望本类， 同一个包下的其他类和子类访问， 使用protected修饰。

3、final

3.1.final的作用

final 关键字是最终的意思， 可以修饰（ 方法， 变量， 类）

修饰方法： 表明该方法是最终方法， 不能被重写。

修饰变量： 表示该变量第一次赋值后， 不能再次被赋值(有且仅能被赋值一次)。

修饰类： 表明该类是最终类， 不能被继承。

3.2.final修饰变量的注意

final修饰的变量是基本类型： 那么变量存储的数据值不能发生改变。

final修饰的变量是引用类型： 那么变量存储的地址值不能发生改变， 但是地址指向的对象内容是可以发生变化的。

示例一：

package com.TianchunGu.d3_final;

//目标：明白final一些基本语法
public class Test {
    //属于类，只加载一次，可以共享（常量）
    public static final String schoolName = "xihua";
    public static final String schoolName2;//未初始化，报错
    static {
     schoolName2 = "honghong";
     //schoolName2 = "xiaoming"//第二次赋值，报错！
    }

    //属于对象的！（final基本上不会用来修饰实例成员变量，没有意义！）
    private final String name = "王麻子";

    public static void main(String[] args) {
        //final修饰变量，变量有且仅能被赋值一次
        //变量有几种：
        //局部变量
        //成员变量
        //  --1、静态成员变量
        //  --2、实例成员变量
        final int age;
        age = 12;
        //age = 20;//第二次赋值，报错了！
        System.out.println(age);

        final double rate = 3.14;

        buy(0.8);

        //schoolName = "hog";//第二次赋值，报错了！
        Test t = new Test();
        //t.name = "maz";//第二次赋值，报错
        System.out.println(t.name);
    }

    public static void buy(final double z){
        //z = 0.1;//第二次赋值，报错了
    }
    //final修饰类，类不能被继承了
    final class Animal{

    }

//    class Cat extends Animal{
//
//    }//final修饰类，类不能被继承了

    //final 修饰方法，方法不能被重写
    class car{
        public final void run(){
            System.out.println("车会跑");
        }
    }

  class bigCar extends car{
//        @Override
//      public void run(){
//            System.out.println("大车跑的慢！");//报错
//        }
  }



}

示例二：

package com.TianchunGu.d3_final;

public class Test2 {
    public static void main(String[] args) {
        //final修饰变量的注意事项
        //1、final修饰基本类型变量，其数据不能再改变
        final double rate = 3.14;
        //rate = 3.6;//第二次赋值，报错！

        //2、final修饰引用数据类型的变量，变量中存储的地址不能被改变，但是地址指向的对象内容可以改变
        final int[] arr = {10,20,30};

        System.out.println(arr);

        //arr = null;//属于第二次赋值，arr中的地址不能被改变

        arr[1] = 200;
        System.out.println(arr);

        System.out.println(arr[1]);

    }
}

4、资料来源：黑马程序员