Java面向对象思想精华（四）

一、包（package）与包的引用

（一）package、import

• package：

1. 作用：为了避免类名冲突。
2. 包名可以有层次结构。类的全称：包名.类名。
3. 建议：包名所有字母都小写。
4. 同包中的类的类名不能同名。

• import：

1. 同包中的类可以直接访问，不同包中的类不能直接访问，只能如下两种方法访问方式：
   1.1、先 import 声明类在使用类------建议。
   1.2、类的全称--------------太繁琐、不建议。

二、访问控制修饰符

（一）public、private、protected、默认的

• public：公开的，任何类都可以访问。
• private：私有的，只能在本类中可访问。
• protected：受保护的，本类、派生类（子类）、同包类可以访问。
• 默认的（另一种说法：有好的）：什么都不写，本类和同包类中可访问。
• 说明：
  • 类的访问修饰符只能 public 或者默认的（不写）。
  • 类的成员的访问修饰符如以上4种都可以。

代码栗子：

package oop.day05;
//同包类：同一个包下的 class 类文件
//演示访问控制修饰符
public class Aoo {
	public int a;    //任何类
	protected int b; //本类、派生类、同包类
	private int d;   //本类
	int c;           //本类、同包类
	
	
	public void show() {
		a = 1;
		b = 2;
		c = 3;
		d = 4;
	}
}

class Boo{ //演示private
	public void show() {
		Aoo o = new Aoo();
		o.a = 1;
		o.b = 2;
		o.c = 3;
		//o.d = 4;
	}
}

同包类（同package oop.day05包下的类）

package oop.day05;
public class Coo { //演示同包类
	public void show() {
		Aoo o = new Aoo();
		o.a = 1;
		o.b = 2;
		o.c = 3;
		//o.d = 4;
	}
}

//同包中
class Doo extends Aoo{ //演示protected
	public void show() {
		a = 1;
		b = 2;
		c = 3;
//		d = 4;
	}
}

不同包的类

package oop.day06;
import oop.day05.Aoo;//先导包
//跨包继承
public class Doo extends Aoo{
	public void show() {
		Aoo aoo = new Aoo();
		aoo.a = 1;
		aoo.show();
	}
}

三、final 关键字修饰的作用

• final 的意思：最终的、不可修改。
• final 修饰变量，修饰方法，修饰类的作用和说明如下：

1. 修饰变量：变量不可被修改。

   /*
    * final修饰成员变量，只能在如下两种方式下初始化:
    * 1)声明同时初始化
    * 2)在构造方法中初始化
    * final修饰局部变量，只要在用之前初始化即可
    */
   //演示final修饰变量
   class Eoo{
   	final int num = 5;
   	final int count;
   	Eoo(){
   		count = 5;
   	}
   	void show() {
   		final int Number;
   		//count = 8; //编译错误，final修饰的变量不能被改变
   	}
   }
   

2. 修饰方法：方法不能被重写。

   //演示final修饰方法
   class Foo{
   	final void show() {}
   	void say() {}
   }
   class Goo extends Foo{
   	//void show() {} //编译错误，final修饰的方法不能被重写
   	void say() {}
   }
   

3. 修饰类：类不能被继承。

   //演示final修饰类
   final class Hoo{}
   //class Ioo extends Hoo{} //编译错误，final的类不能被继承
   class Joo{}
   final class Koo extends Joo{
   
   }
   

四、static静态

（一）静态变量

1. 由 static 修饰。
2. 属于类的，存储在方法区中，只有一份。
3. 常常通过类名点来访问。
4. 什么时候用：所有对象共享的数据。
5. 注意：声明同时并初始化。

（二）静态方法

1. 由 static 修饰。
2. 属于类的，存在方法区中，只有一份。
3. 常常通过类名点来访问。
4. 静态方法中没有隐式 this 传递，所有在静态方法中不能直接访问实例成员。
5. 何时用：方法的操作仅与参数相关，而与对象无关。

（三）静态块

1. 由 static 修饰。
2. 属于类，在类被加载期间自动执行；类只被加载一次，所有静态块也执行一次。
3. 何时用：加载 / 或者初始化静态块即在类加载期间自动执行（执行一次）。
4. 使用场景：例如打开程序时，需要初始化静态资源（图片、音频、视频等）；学到后面阶段有个JDBC知识内容，项目与数据库的连接，需要先加载数据库接口驱动…

代码演示：

//static的演示
public class StaticDemo {
	public static void main(String[] args) {
		Loo o1 = new Loo();
		o1.show();
		Loo o2 = new Loo();
		o2.show();
		Loo o3 = new Loo();
		o3.show();
		System.out.println("最后的静态变量:"+Loo.b); //常常通过类名点来访问
		
		System.out.println("------------------------------------------");
		
		Moo m = new Moo();
		System.out.println(Moo.b);//通过类名点来访问
		System.out.println(m.a);
		int s = m.test2();
		System.out.println(s);
		
		System.out.println("------------------------------------------");
		
		Noo o4 = new Noo();
		Noo o5 = new Noo();
		Noo o6 = new Noo();
	}
}

class Loo{ //演示静态变量
	int a;
	static int b;
	Loo(){
		a++;
		b++;
	}
	void show() {
		System.out.println("静态变量:"+a+","+b);
	}
}
//静态变量，static修饰 属于类的，存储在方法区中，只有一份



class Moo{ //演示静态方法
	int a=88;
	static int b=56;
	void show() { //有隐式this
		System.out.println(this.a);
		System.out.println(Moo.b);
	}
	static void test() { //没有隐式this
		//静态方法没有隐式的this传递
		//没有this就意味着没有对象
		//而实例变量a必须通过对象点来访问
		//所以此处编译错误，因为静态方法中不能直接访问实例成员,得先创建对象再访问。
		
		//System.out.println(a); //编译错误
		System.out.println(b);
	}
	int test2() {
		return a;
	}
}


class Noo{
	static {
		System.out.println("静态块");//静态块只加载一次
	}
	Noo(){
		System.out.println("构造方法");
	}
}

结果图：

五、static final 常量

1. 必须声明同时初始化，才能使用。
2. 通常通过类名点来访问，且不能改变。
3. 建议：常量名所有字母都大写，多个单词用 _ 下划线分隔。
4. 编译器在编译期间将常量直接替换为具体的数，效率高。
5. 何时用：数据需一直不改变时，经常使用。

//static final常量的演示
public class StaticFinalDemo {
	public static void main(String[] args) {
		System.out.println(Aoo1.PI); //常量通过类名点来访问
		//Aoo.PI = 3.1415926; //编译错误，常量不能被改变
		
		
		//1)加载Boo.class到方法区中
		//2)静态变量num也存储到方法区中
		//3)到方法区中获取num的值并输出
		System.out.println(Boo.num);
		
		
		//编译器在编译时将常量直接替换为具体的值，效率高
		//相当于System.out.println(5);
		System.out.println(Boo.COUNT);
		
	}
}

class Boo{
	public static int num = 5; //静态变量
	public static final int COUNT = 5; //常量，常量名所有字母都大写
}

class Aoo1{
	public static final double PI = 3.14159;
	//public static final int NUM; //编译错误，常量必须声明同时初始化
}

后续的内容请耐心等等，马上就来！写作不易请点个赞3Q，Thanks！

章节目录在此处：https://blog.csdn.net/qq_41254299/article/details/106638651

转载请注明出处：https://blog.csdn.net/qq_41254299
本文出自【Superclover_的博客】