JAVA基础（14）-Java修饰词

在讲解权限修饰符之前，我们要先了解一下什么是包

package：包

作用：用于管理源文件,区分类全名
命名规则：域名后缀.域名.项目名.模块名
声明位置：在源文件的首行首句。
类全名：从包开始写起的名称（一般我们在程序中用的都不是类全名，要想直接用类名声明对象，就必须在程序第二行导入要用的类所在的包，如果不导包，就要写类全名才能用）

常用的包:
java.lang.*,因为里面的类型非常常用。因此不需要导包
java.util.*,此包下封装了很多常用的工具类
java.io.*,此包下封装了io流的类型
java.net.*,此包下封装很多关于网络的多种类型

import: 导包关键字：
在class之上，package之下。用于声明类的类全名，在逻辑中就可以使用短的类名。
优点: 可以减少代码的书写。

练习代码：

public static void main(String[] args) {
		java.util.Scanner sc = new java.util.Scanner(System.in);
		System.out.println("姓名：");
		java.lang.String name = sc.next();
		System.out.println(name);
	}

访问权限控制修饰词

private，protected，public，默认的(default)

修饰类时:
外部类：可以使用public和默认的
内部类：可以使用public,protected,默认的,private

修饰成员变量:

四个修饰符都可以进行修饰，可见性不一样

	本类中	同包下	不同包子类中	其他
public	true	true	true	true
protected	true	true	true	×
default	true	true	×	×
private	true	×	×	×

     在实际开发中，成员变量要尽可能的设置成不可见，好处是，提高代码的安全性。即用private修饰为了在其他类中不可以对成员变量进行重新设置值或者获取值，我们可以定义相应成员变量的共有方法来进行操作。

public void setName(String name){
       this.name = name;//修饰成员变量的值
}
public String getName(){
   return name;
}

修饰方法：
与修饰成员变量的可见性一致。
方法的重写:
子类不能重写父类的私有方法

关键字修饰词

final： (最终的，最后的)

(1)修饰类
被final修饰的，不能再有子类了。
(2)修饰成员变量
可以直接初始化，也可以在构造器中初始化，一旦初始化红以就不能再其他任何地方再次赋值。
(3)修饰局部变量
只能初始化一次，之后不能再次赋值。
(4)修饰方法
被final修饰的方法，不能再子类中重写

练习代码：

public class Practice01 {
	public static void main(String[] args) {
		Velicle v = new Velicle(4, 80);
		//v.speed=30;  final修饰的成员变量不能修改
		final int sp = 100;
		Car car = new Car(4, sp, 3);
		//sp = 120;final修饰的变量不能修改
	}
}
class Velicle{
	public  int wheel;
	public final int speed;
	public Velicle(int wheel, int speed) {
		this.wheel = wheel;
		this.speed = speed;
	}
	public void run() {
		System.out.println("开动");
	}
	public final void backACar() {
		System.out.println("倒车");
	}
}
final class Car extends Velicle{
	private double weight;

	public Car(int wheel, int speed, double weight) {
		super(wheel, speed);
		this.weight = weight; 
	}
	public void run() {
		//this.speed++;  //final修饰的成员变量不能修改
		System.out.println("车加速");
	}
	//final修饰的方法不能被重写
//	public final void backACar() {
//		System.out.println("倒车");
//	}                            
}
//final修饰的类不能被继承
//Class Porsche extends Car{
//	
//}

static：(英文含义：静态)
1、修饰成员变量
(1)修饰的成员变量，不属于对象的数据结构
(2)静态变量属于类的，通常使用类名去调用
(3)静态变量与类的信息一起存在方法区中，只存在一份，是对象的公共资源
  2、修饰方法
(1)通常的方法都是与具体对象有关系，即对象的方法(行为)
   (2)如果是static方法则与对象毫无关系，是类的方法，通常用类名去调用，常常与参数有关系
   (3)static方法内因为无法使用this关键字，因此不能直接访问非静态成员
(4)static方法的作用一般都用于设计成"工具方法"和"工厂方法"

如: Arrays.sort(数组名);
Math.random();
   Math.sqrt(参);
   Math.abs(参);
      Math.sin(参数);

使用static修饰词在内存中的样子：

  3、static修饰代码块
static{
代码逻辑
}
静态块存储在方法区中，只加载一次，与对象无关。
执行时机为加载类的信息期间，可以理解为在实例化之前

作用：通常用于加载程序中所需要的静态资源:如：图片，音频，视频等

非静态代码块与静态代码块，成员变量，方法都是类的成员
{
}
运行时机：在实例化之前执行，每次实例化之前都会执行一次

练习代码：

public class StaticDemo {
	static int num2 = 10; //static修饰的变量不能写到main方法中
	int num1 = 5;
	public static void main(String[] args) {
		//num1 = 5; 静态方法中不能直接调用非静态变量或方法
		StaticDemo s = new StaticDemo();
		int num = s.num1;    //间接调用num1;
		int num3 = 5;        //在静态方法中可以创建非静态变量，之后可直接使用
		System.out.println("static = "+num2);
		System.out.println("int = "+num);
		System.out.println("num3 = "+num3);
	}
}

public static void main(String[] args) {
		run();  //static修饰的方法在main方法中可直接写方法名来调用
		//jump();  //普通方法不能只戒掉用
		Practice04 p = new Practice04();
		p.jump(); //非静态方法在main方法中可间接调用
	}
	public static void run() {
		System.out.println("跑");
	}
	public void jump() {
		System.out.println("跳");
	}

说完了static，和final修饰词，我还要了解一下这两个关键词在一起时会是什么样

常量：
一般都是一些特殊值，一般都使用成员变量，修饰词为public static final
声明时必须初始化
命名规则：字母全都大写
如: Math.PI