java基础中的--------抽象类+final关键字+包+权限修饰符（有惊吓！！！）

本文链接：https://blog.csdn.net/liutaiwu/article/details/107390663

在这里插入图片描述

一.抽象类

1.抽象方法

抽象：抽取像的，相同的，相似的内容出来。

抽象方法：只有方法声明，而没有方法的实现的方法，就是抽象方法。
在各个子类中，对于某个方法都有自己的不同的实现，所以实现各不相同，无法抽取，只能抽取方法的声明上来，在父类中，方法就只有方法声明的没有方法体，就是抽象方法。
定义格式
在方法声明上加上abstract 关键字
没有方法体，所以在方法的参数列表后直接加上；号结束.

abstract class Animal{
	
	public abstract void eat();
	
}
class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃狗粮");
	}
	
}
class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃猫粮");
	}
	
}

2.抽象类

1.可以定义抽象方法的类，就是抽象类。
2.定义格式：
abstract class 类名{}

abstract class Animal{
	
	public abstract void eat();
	
}

3.抽象类的特点

1.抽象类和抽象方法的关系
抽象方法所在的类必须是抽象类
抽象类中未必一定都定义抽象方法，抽象类中未必存在抽象方法

2.抽象类不能实例化
抽象类可以存在构造方法，目的是为了给子类进行初始化操作

3.子类进行继承
在子类中，将父类的所有抽象方法全部重写（实现），子类就成了一个普通类，就可以创建对象
在子类中，没有将父类的所有抽象方法全部实现，子类仍然还是一个抽象类，还需使用abstract关键字修饰子类

public class Demo02 {

	public static void main(String[] args) {
		//Demo d = new Demo();
		Zi1 zi1 = new Zi1();
		zi1.method02();

	}

}
/*abstract class Demo{
	
	public Demo() {
		
	}
	
	abstract void method();
	
	public void show() {
		
	}
}*/
abstract class Fu{
	
	public abstract void method01();
	public abstract void method02();
	
	
}
abstract class Zi2 extends Fu{

	@Override
	public void method01() {
		System.out.println("zi1 method01 run...");
		
	}

	
	
}
class Zi1 extends Fu{

	@Override
	public void method01() {
		System.out.println("zi1 method01 run...");
		
	}

	@Override
	public void method02() {
		System.out.println("zi1 method02 run...");
		
	}
	
}

4.抽象类成员的特点

1.成员变量：可以定义变量，也可以定义常量，但是不能被抽象

2.构造方法：有
为子类使用的数据进行初始化

3.成员方法
既可以是抽象方法：强制子类重写
也可以是已实现的方法：用于给子类继承，提高代码的复用性

public class Demo03 {

	public static void main(String[] args) {
		
	}

}
abstract class Demo{
	//abstract int i = 20;
	
	public abstract void method();
	
	public void show() {
		System.out.println("show invoke...");
	}
}

5.练习

程序员属性：姓名、年龄、工资工作：敲代码
测试工程师工作：找BUG
项目经理工作：控制项目进度

public class Demo04 {

}
abstract class Employee{
	String name;
	int age;
	public abstract void work();
}
class Coder extends Employee{

	int bonous;
	@Override
	public void work() {
		System.out.println("敲代码");
		
	}
	
}
class Manager extends Employee{

	@Override
	public void work() {
		System.out.println("控制进度");
		
	}
}

在这里插入图片描述

二.final关键字

final概述

final是个修饰符。
final的含义是“终极版本。
final可以修饰变量、方法、类、方法参数。

final修饰变量

此时的变量转为常量。
此变量在第一次被赋值后，再不能修改它的值。
示例代码

public class Test{
	private final int age=10;  // 必须赋值
	public void method(){
		age = 100;  // 编译报错，不能重新赋值
	}
}

成员常量一般也做成static类型，因为没有必要为每个实例提供一份根本不会变化的变量空间。

常量的定义规则
public static final double PI=3.14;
1：public ：访问权限最大
2：static ：内存中只有一份
3：final ：是一个常量
4：常量名大写，多个单词用下划线（_）分隔
5：必须初赋值，赋值后，不能重新赋值。

示例代码

public class Demo01_final修饰变量 {

}
class Constants{  //定义常量类----这个类中全都存放常量
	public static final double PI = 3.14;
	public static final int DAY_OF_WEEK = 7;
}
class A{
	
	public final String str = "ADMIN";  // 被final修饰的成员变量
	// 在java中定义常量 的格式通常是：
	public static final double PI=3.14;
	public void hello(){
		System.out.println(Constants.DAY_OF_WEEK);  // 使用常量
	}
}

final修饰方法

该方法是最终方法，不能被子类重写。

class A{
	public final void sayHello(){
		System.out.println("你好");
	}
}

class B extends A{
	public  void sayHello(){ // 编译报错——不能重写父类中被final修饰的方	
	}
}

final修饰类

该类是最终类，不能被继承。
查看api文档发现String类是final的。Integer类也是final的。
为了防止代码功能被重写，该类没有必要进行扩展。

final class AA{
	
}

class BB extends AA{  // 编译报错——被final修饰的类，不能被继承     jdk中的String类就是不能被继承的
	
}

final修饰局部变量

final修饰的局部变量不能重新赋值。

class X{  // final修饰局部变量
	public void hello(){
		final int x = 100;
		x = 200;  //final修饰的局部变量，不能重新赋值	
	}
}

final修饰形参

1：当形参被修饰为final,那么该形参所属的方法中不能被篡改（重新赋值）。
2：项目中主要用于一些只用来遍历未知数据的方法。将未知变量声明为final的。增强数据的安全性。


  public class TestFinal {
	/*
	 * 用final修饰方法的形参
	 * */
	public static void printStudentName(final Student s){
		  //s.setName("yyy");  // 这句不是为形参重新赋值
		  //s = new Student(2,"李四"); // 因为final修饰了形参，所以不能重新赋值
	      System.out.println(s.getName());
	}
	
	public static void add(final int x, final int y){
		/*  因为final修饰了 形参，所以在方法中不能为 形参重新赋值
		x = 10;
		y = 10;
		*/
		System.out.println(x+y);
	}
	public static void main(String[] args) {
		Student s = new Student(1,"xxx");
		printStudentName(s);
		add(100, 100);
	}
}

在这里插入图片描述

三、包

1、包

（1）包的概念

 包是Java程序组织文件的一种方式，实质就是文件夹。
 **包的作用：**
     1、方便管理大型软件系统中数目众多的类。
     2、相同名称的类可以放到不同的包中解决了命名冲突的问题。

（2）基本用法

Java语言用package语句表示建立一个包，该语句必须放到源文件的非注释第一句。package语句下声明的类存放到该包（文件夹）中，语法如下：
  package pkg1[.pkg2…];
  例如：package com.offcn.test 系统自动建立三个文件夹，结构如下：
com
      offcn
            test

该文件中所定义的类都在test文件夹下。

示例代码

package com.offcn.finaltest;

（3）JDK中的包

1、java.lang包含一些Java语言的核心类，如String、Math、Integer 、System和Thread，提供常用功能。
2、java.util包含一些实用工具类，如集合、日期等。
3、java.io 包含能提供多种输入/输出功能的类。
4、java.net包含执行与网络相关的操作的类。
5、java.awt包含构成抽象窗口工具集的多个类，这些类用来创建和管理应用程序的图形用户界面（GUI）。

（4）import语句

 如果将一个类放入包中，则使用该类时，必须使用该类的全名。（例如com.offcn.Student）,Java编译器才能找到该类。如果在文件中多次使用Student，则每次都要使用类全名，比较麻烦。
 解决方式：使用import语句
 例如：
 import com.offcn.Student;引入该类，以后每次使用Student类，只需使用类名即可，无需只用类全名。
 或者：
 import com.offcn.*;引入该包下所有类。

 使用import语句应该注意的几点：
 1、import语句定义在package语句后。
 2、java.lang包是默认被导入的，该包下所有类都可以直接使用。
 3、包的导入不是迭代的，也就是当使用com.offcn.*时只会导入该包下的所有类，如果该包下有文件夹a，则a下的所有类不会被导入。
 4、同一个包下的类，不需要导入。

示例代码

package com.offcn.b;

import com.offcn.a.Student; //导入
//import java.util.Random;
import java.util.*;  // 导入java.util包下的所有类

public class Test {
	// 要使用 com.offcn.a 下的Student
	public static void main(String[] args) {
		/*
		com.offcn.a.Student stu = new com.offcn.a.Student();
		stu.study();
	    */
		Student stu = new Student();
		stu.study();
		
		/*
		java.util.Random r = new java.util.Random();
		int x = r.nextInt();
		System.out.println(x);
	    */
		Random r = new Random();
		int x = r.nextInt();
		System.out.println(x);
	}
}

（5）静态导入(了解)

1、静态导入是JDK5.0开始引入的特性。

2、要使用静态成员（方法和变量）我们必须给出提供这个静态成员的类，使用静态导入可以使被导入类的静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。
例如：

public class Common {

public static final int AGE = 10;
public static void output() { 
      System.out.println("Hello World!"); 
} 

}

在另一个包中使用时，如果不用静态导入，是这样用的：
前面加入了导入语句，将Common类导入，使用其中的静态成员变量和静态方法时需要加上类名。

import com.offcn.Common; 
public class Test { 
       public static void main(String[] args) {
            int a = Common.AGE; 
            System.out.println(a); 
            Common.output(); 
       } 
}

使用静态导入
静态导入的语法是：
import static 包名.类名.静态成员变量;
import static 包名.类名.静态成员函数;
注意导入的是成员变量和方法名。
如前面的程序使用静态导入后：

import static com.offcn.Common.AGE; 
import static com.offcn.Common.output; 
public class Test { 
     public static void main(String[] args) { 
          int a = AGE; 
          System.out.println(a); 
          output(); 
     } 
}

在这里插入图片描述

四、权限修饰符

Java通过访问控制修饰符对类和类中的成员进行访问权限的控制。

Java中的访问控制符，包括4个，分别是：
private(私有的)
default（默认的）注意：并不是使用default关键字，而是省略访问控制符。
protected（受保护的）
public（公共的）

各个访问控制符的访问权限控制如下：
在这里插入图片描述

public class Demo01 {
	private int aa = 1;       // 私有的  
	int bb = 2;               // 默认的
	protected int cc = 3;     // 受保护的
	public int dd = 4;        // 公共的   
 
	public void test1(){  // 本类中访问，都可以
		System.out.println(aa);
		System.out.println(bb);
		System.out.println(cc);
		System.out.println(dd);
	}
}

public class Demo02 extends Demo01 {  // 同包子类
	 public void test(){
		 //System.out.println(aa);  // 不能访问私有的
		 System.out.println(bb);
		 System.out.println(cc);
		 System.out.println(dd);
	 }
}

public class Demo03 extends Demo01{ // 不同包子类
	public void test(){
		//System.out.println(aa);
		//System.out.println(bb);  // 不同包中，default的也不能访问
		System.out.println(cc);
		System.out.println(dd);
	}
}

public class Demo04 {  // 不同包类
	public static void main(String[] args) {
	    Demo01 demo = new Demo01();
	    //System.out.println(demo.aa);
	    //System.out.println(demo.bb);
		//System.out.println(demo.cc); 
	    System.out.println(demo.dd);
	}
}

在这里插入图片描述