Java基础12-eclipse工具链接源码、final关键字、package和import、访问控制权限

B站动力节点Java基础视频的学习笔记

eclipse工具链接源码

• 关于eclipse怎么链接源码？
  • 打开某个.class字节码文件，当没有看到源码的时候：
    • 点击"Attached Source":
      • Workspace…【源码在当前的工作区当中】
      • External File…【源码在某个压缩包当中】
      • External Folder…【源码在某个目录当中】
• 以后尽量所有的程序都链接源码，没有源码从网上找
• 养成看源代码的好习惯
• 这里只做标记，具体步骤跟随视频Java基础-P155
• 对于以后大家所学习的类库，一般都是三个部分的：
  • 源码【可以看源码来理解程序】
  • 字节码【程序开发的过程中使用的就是这部分】
  • 帮助文档【对开发提供帮助】
• 注意使用的时候JDK版本统一

final关键字

final关键字的作用综述：

1.final是一个关键字，表示最终的，不可变的
2.final修饰的类无法被继承
3.final修饰的方法无法被覆盖
4.final修饰的变量一旦赋值之后，不可重新赋值【不可二次赋值】
5.final修饰的实例变量，必须手动赋值，不能系统默认赋值
6.final修饰的引用，一旦指向某个对象之后，不能再指向其他对象，那么被指向的对象无法被垃圾回收器回收。
7.final修饰的实例变量是不可变的，这种变量一般和static联合使用，被称为“常量”

详细阐述：

• 1.final是一个关键字，表示最终的，不可变的
• 2.final修饰的类无法被继承

package com.bjpowernde.javase.test003;

public final class A {

}

package com.bjpowernde.javase.test003;

/*
public class B extends A {

}*/

public class B{

}

• 3.final修饰的方法无法被覆盖

package com.bjpowernde.javase.test003;

public class C {
	
	public final void doSome() {
		
	}
	
}

package com.bjpowernde.javase.test003;

public class D extends C {
	
	/*
	public final void doSome() {
		
	}*/
}

• 4.final修饰的变量一旦赋值之后，不可重新赋值【不可二次赋值】

public class FinalTest01 {

	public static void main(String[] args) {
		
		int i = 10;
		System.out.println(i);
		i = 20;
		System.out.println(i);
		
		final int k = 100;
		//编译错误：无法为最终变量k分配值
		//k = 200;
		
		final int g;
		g = 200;
		//编译错误：无法为最终变量g分配值
		//g = 300;
	}
}

• 5.final修饰的实例变量，必须手动赋值，不能系统默认赋值

package com.bjpowernde.javase.test003;

public class FinalTest02 {
	
	//成员变量之实例变量
	//实例变量有默认值 + final修饰的变量一旦赋值不能修改
	//综合考虑，java语言实例变量使用final修饰之后，必须手动赋值，不能采用系统默认赋值
	//编译错误
	//final int age;
	
	//第一种解决方案
	final int age = 100;
	
	//第二种解决方法
	final int num;
	public FinalTest02(){
		this.num = 100;
	}
	
	//以上的两种解决方案：其实本质上就是一种方式，都是在构造方法执行过程当中给实例变量赋值。
	
	public static void main(String[] args) {
		
	}
}

• 6.final修饰的引用，一旦指向某个对象之后，不能再指向其他对象，那么被指向的对象无法被垃圾回收器回收。

package com.bjpowernde.javase.test003;

public class User {
	int id;

	public User(int id) {
		super();
		this.id = id;
	}	
}

package com.bjpowernde.javase.test003;

public class FinalTest03 {
	public static void main(String[] args) {
		//创建用户对象
		User u = new User(100); //User u = 0x1234;
		
		//又创建了一个新的User对象
		//程序又执行到此处表示以上对象已变成垃圾数据，等待垃圾回收器的回收
		u = new User(200);//u = 0x2356;
		
		//创建用户对象
		final User user = new User(30);
		System.out.println(user.id);
		//user = new User(100);//final修饰的引用，一旦指向某个对象之后，不能再指向其他对象，那么被指向的对象无法被垃圾回收器回收。
		
		user.id = 50;//final修饰的引用虽然指向某个对象之后不能指向其他对象，但是所指的对象内部的内存是可以被修改的。
		System.out.println(user.id);
	}
}

• 7.final修饰的实例变量是不可变的，这种变量一般和static联合使用，被称为“常量”

package com.bjpowernde.javase.test003;

public class FinalTest04 {

	public static void main(String[] args) {
		
		System.out.println(Chinese.GUO_JI);
		
	}

}

class Chinese{
	
	//国籍
	//需求：每一个中国人的国籍都是中国，而且国籍不会发生改变，为了防止国籍被修改，建议加final修饰
	//final修饰的实例变量是不可变的，这种变量一般和static联合使用，被称为“常量”
	//常量的定义语法格式：
    //  public static final 类型 常量名 = 值;
	//java规范中要求所有常量的名字全部大写，每个单词之间使用下划线连接
	
	public static final String GUO_JI = "中国";
	
	//GUO_JI = "美国";
}

package和import

使用EditPlus编辑器编写

• package机制

/*
	关于java语言当中的包机制：
		
	1.包又称为package，java中引入package这种语法机制主要是为了方便程序的管理。
	不同功能的类被分门别类放到不同的软件包当中，查找比较方便，管理比较方便，易维护。

	2.怎么定义pacakeg呢？
		- 在java源程序的第一行上编写pacakage语句
		- package只能编写 一个语句
		- 语法结构：
			package 包名;
	
	3.包名的命名规范：

		公司域名倒序 + 项目名 + 模块名 + 功能名;
		
		采用这种方式重名的几率较低，因为公司域名具有全球唯一性。

		例如：
			com.bjpowernode.oa.user.service;
			org.apache.tomcat.core;
	
	4.包名要求全部小写，包名也是标识符，必须遵守标识符的命名规则。

	5.一个包对应一个目录。

	6.使用了package机制之后，应该怎么编译？怎么运行呢？

		- 使用了package机制之后，类名不再是Test01了，类名是com.bjpowernode.javase. day11.Test01

		- 编译：javac java源文件路径（在硬盘上生成了一个class文件：Test01.calss）

		- 手动方式创建目录：将Test01.class字节码文件放到指定的目录下

		- 运行：java com.bjpowernode.javase.day10.Test01
		
		- 另一种方式（编译 + 运行）：

			* 编译：
				javac -d 编译之后存放路径 java源文件的路径

			* 例如：将F:\Hello.java文件编译之后放到C:\目录下
				javac -d C:\ F:\Hello.java

			* javac -d . *.java
				将当前路径中*.java编译之后存放到当前目录下

			* 运行：JVM的类加载器ClassLoader默认从当前路径下加载。
				保证DOS命令窗口的路径先切换到com所在的路径，执行：
					java com.bjpowernode.javase.day11.Test01

*/

package com.bjpowernode.javase.day10;//4个目录【目录之间使用.隔开】

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

		System.out.println("Test01's main method execute!");
	
	}
}

package com.bjpowernode.javase.day10;

public class Test02
{
	public static void main(String[] args)
	{
		//完整类名是：com.bjpowernode.javase.day10.Test01
		com.bjpowernode.javase.day10.Test01 t = new com.bjpowernode.javase.day10.Test01();
		 System.out.println(t);//com.bjpowernode.javase.day10.Test01@15db9742
		
		//可以省略包名：Test01和Test02在同一目录下，同一软件包下
		 Test01 tt = new Test01();
		 System.out.println(tt);//com.bjpowernode.javase.day10.Test01@6d06d69c
	}

}	

package com.bjpowernode;

public class Test03
{
	public static void main(String[] args)
	{
		//创建Test01对象
		//以下代码编译错误：当省略包名之后，会在当前包下找Tes01
		//实际上编译器去找：com.bjpowernode.Test01了。这个类不存在
		//Test01 t = new Test01();
		//System.out.println(t);

		//修改以上错误
		//包名不要省略，添加包名
		//结论：什么时候前边的包名可以省略呢？Test01和Test03在同一个包下的时候不需要加包名
		com.bjpowernode.javase.day10.Test01 tt = new com.bjpowernode.javase.day10.Test01();
		System.out.println(tt);//com.bjpowernode.javase.day10.Test01@15db9742
	}
}

• import机制

package org.apache;

//import com.bjpowernode.javase.day10.Test01;
import com.bjpowernode.javase.day10.*;

import java.util.*;
import java.util.Date;

/*
	import语句用来完成导入其他类，同一个包下的类不需要导入，
	不再同一个包下需要手动导入。

	import语法格式：
		import 类名;
		import 包名.*;

	import语句需要编写到package语句之下，class语句之上
*/


public class Test04
{
	public static void main(String[] args){
		com.bjpowernode.javase.day10.Test01 tt = new com.bjpowernode.javase.day10.Test01();
		System.out.println(tt);

		com.bjpowernode.javase.day10.Test01 ttt = new com.bjpowernode.javase.day10.Test01();
		System.out.println(ttt);

		com.bjpowernode.javase.day10.Test01 tttt = new com.bjpowernode.javase.day10.Test01();
		System.out.println(tttt);
		//以上程序可以，就是有些复杂

		Test01 x = new Test01();
		System.out.println(x);//com.bjpowernode.javase.day10.Test01@4e25154f
		
		//java.lang.*不需要手动引入，系统自动引入
		//lang：language语言包，是java语言的核心类，不需要手动引入
		String s = "abc";
		System.out.println(s);
		
		//直接编写以下代码编译错误，因为Date类没有找到
		//Date d = new Date();

		//java.util.Date d = new java.util.Date();

		//使用import语句之后：import java.util.Date;
		Date d = new Date();
	}
}

eclipse编辑器

package com.bjpowernde.javase.test004;




//eclipse导入包的快捷键：ctrl + shift + o
import com.bjpowernde.javase.test001.Cat;
import com.bjpowernde.javase.test001.*;

import java.util.Date;

public class Test {

	public static void main(String[] args) {
		
		//编译错误，找不到Cat类
		//Cat c = new Cat();
		
		//包名.类名
		com.bjpowernde.javase.test001.Cat c = new com.bjpowernde.javase.test001.Cat();
		System.out.println(c);
		
		//import 包名
		Cat cc = new Cat();
		System.out.println(cc);
		
		Date d = new Date();
		System.out.println(d);
	}

}

访问控制权限

package com.bjpowernde.javase.test005;

/**
访问控制权限修饰符：

	1.访问控制权限修饰符来控制元素的访问权限；
	
	2.访问控制权限符包括：
		public    表示公开的，在任何位置都可以访问
		protected 同包，子类
		缺省              同包
		private   表示私有的，只能在本类中访问
		
	3.访问控制权限修饰符可以修饰类、变量、方法...
	
	4.当某个数据只能使子类使用，使用protected进行修饰
	
	5.修饰符的范围：
		private < 缺省 < protected < public 
 */
=