day_11 封装、继承、final、super、覆写

最新推荐文章于 2025-12-20 22:10:08 发布

原创最新推荐文章于 2025-12-20 22:10:08 发布 · 107 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#eclipse #java

本文介绍了Java中的封装概念，包括包的使用、import语句的作用以及权限控制。讨论了继承的特性，如单继承、代码复用以及super关键字的应用。此外，还详细阐述了覆盖（override）方法的条件和意义，以及final关键字在类、方法和变量上的应用。

1.封装

 * 封装 : 控制用户对类的修改程度,隐藏属性和行为的具体实现,只提供公开的接口即可

1.1Package

/**
 * package:软件包机制
 * 		限制的是编译之后的class文件的保存目录,和源文件无关
 * 		eclipse中,源文件也必须在这个目录中,这是eclipse的问题,和package无关
 *		而java中的package只是规定class文件
 *	1 主要问了解决命名冲突问题
 *	2 package语句必须出现在java源文件的第一行
 * 	3 一般采用公司域名倒叙的方式
 * 		域名倒叙.项目名.模块名
 * 	4 带有package语句烦人java文件 应该这样编译
 * 		javac -d 生成路径 字符编码 源文件路径
 * 		javac -d./-们从定 utf-8 xxx.java
 * 			-d :disk磁盘
 * 			./  :代表当前目录
 *  5 运行
 *  java 包名.类名
 * @author 学到头秃的张张张
 *@Date 2021年10月13日下午6:08:22
 */

1.2import

package day11.package1;

public class User {

	public void m1() {
		System.out.println("成员方法");

	}

}

package day11;

public class Text02 {

	public static void main(String[] args) {
		//调用一个不是本包中的类.需要写全类名
		//包名.类名
		day11.package1.User user =new day11.package1.User();
		user.m1();

	}

}

package day11;
//导入对应的这个类
import day11.package1.User;
//.*是导入对应包下的所有类
import java.util.*;
//java.lang.*;下的所有类,为系统核心类,可以直接使用,不需要导入
/**
 * import
 * 用于导入当前类中需要用到的其他类
 * 该语句必须在package语句之下,class之上
 * @author 学到头秃的张张张
 *@Date 2021年10月13日下午6:55:40
 */
public class Text03 {
	public static void main(String[] args) {
		String str ="xxx";
		//调用一个不是本宝中的类需要写全类名
		//包名.类名
		/**
		 * 注意 : 写代码的时候,使用eclipse按空格  会自动导入对应的包
		 * 如果程序没有问题,但是报错,可以查看一下,是否是导包错误了
		 */
		User user= new User();
		user.m1();

	}

}

package day11;
//静态导入访问一个类的静态属性的时候,需要使用 类名.静态属性访问
//但是静态属性导入之后,就可以直接写静态属性访问
import static day11.package1.User.*;
import day11.package1.User;

public class Text04 {
	public static void main(String[] args) {
		//类名.静态变量名
		System.out.println(User.a);
		//因为静态导入了,所以可以直接写变量名
		//不建议使用,因为在当前类中不容易看出来这个变量到底是谁的
		System.out.println(a);

	}

}

1.3权限控制

package day11;
import day11.package2.User;

public class Text06 {

	public static void main(String[] args) {
		System.out.println(User.a);
		//除了a都不能访问 因为不在同一个包里
		//	System.out.println(User.b);
		//	System.out.println(User.c);
		//	System.out.println(User.d);
		
		//除了b都能访问 因为是私有权限
		System.out.println(Text05.a);
		//System.out.println(Text05.b);
		System.out.println(Text05.c);
		System.out.println(Text05.d);
	}

}

2.继承

2.1是什么

/**
 * 1 继承 : 
 *   继承 就是在已有类中派生出新的类,新的类能够吸收父类已有的属性和行为,并且还能扩展自己的属性和行为
 *   
 *  2 继承特点
 *    java中 只支持单继承,不支持多继承 ,这样使java 的继承体系更加简单清晰
 *    		一个类只能有一个父类,但是一个类可以有很多子类
 *    继承关系是可以进行传递的
 *    
 *    private私有化属性不能被继承
 */

2.2能做什么

/**
 * 	3 解决什么问题?
 * 		提高 代码的复用,提高开发效率
 * 
 * 一个类如果没有显示继承另一个类,那么该类默认继承 Object
 * 		java.lang.Object ,是java提供的根类(祖宗) ,也就意味着 Object中的所有属性是所有类都有的
 */

2.3怎么用

package day11;

public class Supclass {
	public void m1(){
		System.out.println("父类m1");
	}
}

package day11;

public class Subclass extends Supclass {
	public void m2(){
		System.out.println("子类m2");
	}
}

package day11;

public class Text07 {

	public static void main(String[] args) {
		Subclass subClass = new Subclass();
		// 调用继承自父类的方法
		subClass.m1();
		// 调用自己的方法
		subClass.m2();
		// 因为所有类都直接间接继承Object,而toString就是Object中的方法
		subClass.toString();}

}

3.super

3.1是什么

/**
 * super : 官方给的说法是,代表了父类型特征,可以理解为父类对象
 * 		通过子类中,可以使用super关键字,来标识父类,通过this来标识自己
 */

3.2能做什么

/**
 * 1 不能再静态上下文中使用
 * 2 用在构造方法或者成员方法中 ,区分子类和父类同名的变量和方法
 * 		super.xxx = xxx;  super.m1();
 * 3 用在子类构造方法中,调用父类的构造方法
 * 			super(参数);   必须出现在子类构造方法第一行
 * 			this(参数) : 也必须出现在第一行,所以 他们两个不能同时出现
 * 		如果 构造方法第一行 , 没有出现 this(参数) 也没有出现 super(参数)  
 * 			则默认有个super()  调用父类的无参构造
 * 
 * @author 学到头秃的张张张
 *@Date 2021年10月13日下午7:42:21
 */

3.3怎么用

package day11;

public class SupClass_ {
	int i = 1;
	public void m1(){
		System.out.println("父类m1");
	}
	public SupClass_(){
		super();
		System.out.println("父类构造");
	}
	public SupClass_(int i){
		super();
		System.out.println("父类构造"+i);
	}
}

package day11;

public class SubClass_  extends SupClass_{
	int i = 2;
	public void m1(){
		System.out.println("子类m1");
	}
	public void test(){
		// 由于子类也有,所以默认使用子类的
		System.out.println(i);
		// 想使用父类的,需要使用super区分
		System.out.println(super.i);
		m1();
		super.m1();
	}
	public SubClass_(){
		// 可以调用父类指定的构造方法,默认是调用无参
		super(22);
		System.out.println("子类构造");
	}

}

3.4注意

1.this(...)和super(...)不能同时出现

2 如果没有this(...) 和 super(...) ,默认构造方法第一行会有super()调用父类无参构造

3 如果构造方法私有化,则该类不能被继承

package day11;

public class Text09 {

	private Text09(){
		
	}
}
// 构造方法私有化之后,不能被继承,因为子类构造方法中,需要调用父类构造方法
//但是因为私有化的问题,导致子类调用不了
//class Test extends Text09{
//	
//}

3.5优先级

package day11;
/**
 * Cannot define static initializer in inner type Text10.Sup
 * @author 学到头秃的张张张
 *@Date 2021年10月13日下午8:22:34
 */
public class Text10 {

	public static void main(String[] args) {
		new Sub();
		}
}
	class Sub extends Sup {
		static {
			System.out.println("子类静态语句块");
		}

		{
			System.out.println("子类实例语句块");
		}

		public Sub() {
			System.out.println("子类构造");
		}
	}

	class Sup {
		static {
			System.out.println("父类静态语句块");
		}
		{
			System.out.println("父类实例语句块");
		}

		public Sup() {
			System.out.println("父类构造");
		}
	}

4.覆写

4.1是什么

/**
 * override : 方法的覆写/重写
 * 
 * 什么时候需要重写 : 当父类功能无法满足子类需求的时候,子类需要根据需求对方法进行重写
 * 
 * 方法 覆写 特指成员方法,只有成员方法可以被覆写,和 静态方法,静态变量,成员变量 都没有关系
 */

4.2应用场景

/**
 * 重写的必要条件
 * 1 必须有继承关系的体系中
 * 2 方法名必须一致 ,方法名不同,就是两个方法了,跟重写没有关系
 * 3 参数列表必须一致,如果参数列表不一致,就是方法重载
 * 4 返回值必须一致,返回值表示反馈的功能,不更改功能
 * 5 不能比原方法有更宽泛的异常(错误不能越来越多)
 * 6 不能比原方法拥有更低的访问权限
 * 
 * 重写的意义 : 
 * 		功能越来越强
 * 		错误越来越少
 * 		使用范围越来越广
 * 
 * override和overload的区别
 * 			1 分别是什么
 * 			2 分别能干什么
 * 			3 区别
 * 
 * @author 学到头秃的张张张
 *@Date 2021年10月13日下午7:58:29
 */

package day11;

public class Text11 {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.move();
	}
}
class Animal{
	public void move(){
		System.out.println("动物移动");
	}
}
class Cat extends Animal{
	// @Override注解 标识该方法是覆写的父类的方法
	// 如果加着该注解,方法如果不小心写错了,比如方法名拼写错误的时候,会提示有错
	@Override
	public void move() {
		System.out.println("猫......在跳高");
	}

}

5.final

5.1是什么

 * final 是修饰符,表示最后的,最终的,不可更改的

5.2能做什么

/**
 * final修饰的类 不能被继承
 * final修饰的方法 不能被覆写
 * final修饰的变量 不能二次赋值,并且没有默认值
 * final修饰的静态变量,一般叫常量 , 一般使用 public static final 修饰,常量名建议全部大写
 * 
 * @author 学到头秃的张张张
 *@Date 2021年10月13日下午8:06:11
 */

5.3怎么用

//final class A{
//}
// 不能继承,因为A是最终的,使用final修饰了
//class B extends A{
//}

class A{
	public final void m1(){
	}
}

//class B extends A {
	// @Override
	// 不能覆写,因为m1使用final修饰 是最终的
	// public void m1() {
	// }
//}

public class Text12 {

	// 没有默认值,会报错
	// final int a ;

	final int i;

	Text12(int i) {
		this.i = i;
		// 不能二次赋值
		// this.i = i;
	}
}

//常量
class MyMath{
	public static final double PI = 3.14;
}

5.4深入final

package day11;
/**
 * 深入final : final修饰的引用类型,地址不能更改,和地址对应的数据 没有关系
 * @author 学到头秃的张张张
 *@Date 2021年10月13日下午8:13:07
 */
public class Text13 {

	public static void main(String[] args) {
		final int i = 1;
		// i = 2;

		final Customer c = new Customer("张三", 18);
		// c中保存的地址,根据地址找到的数据是可以更改的,因为name又没有加final修饰
		c.name = "李四";
		// 因为c使用final修饰了,所以c不能再更改为其他值
		// c = null;
		// c = new Customer("张三", 18);
		System.out.println(c.name);
		System.out.println(c.age);
	}

}
class Customer {
	String name;
	int age;

	public Customer(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
}