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

package Package;
/**
 * import 
 *  调用不是本包的类
 * @author 人间失格
 * @data     2021年10月13日下午7:55:33
 */
public class Package_02 {

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

}

package Package;
//导入对应的这个类
//.* 是导入对应包下的所有类
import java.util.*;
import day_03._01_Package.com.User;
//java.lang.*; 下的所有类,为系统核心类,可以直接使用,不需要导入
/**
 * import 用于导入当前类中需要用到的其他类
 * 该语句 必须在package语句之下, class语句之上
 * @author 人间失格
 * @data     2021年10月13日下午8:19:47
 */
public class Package_03 {

	public static void main(String[] args) {
		String str = "xxx";
		//调用一个不是本包中的类,需要写类的全名
		//包名.类名
		/**
		 * 注意: 写代码的时候,使用eclipse空格 会自动导入对应的包
		 * 
		 * 如果程序没有问题,但是报错,可以查看一下,是否是导包错误了
		 */
		User user = new User();
		user.m1();
	}

}

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

public class Package_04 {

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

}

1.3 权限控制

package day_03._02_PPP.pojo;

public class User {
	// public : 哪都行共有的
	public static int a = 1;
	// private : 除了当前类,那都不行 私有的
	private static int b = 2;
	// 默认 是包权限,同包可以访问 
	static int c = 3;
	// 继承权限,要么同包,要么有继承关系
	protected static int d = 4;
}

package PPP;
import day_03._02_PPP.pojo.User;
public class PPP_01 {

	public static void main(String[] args) {
		System.out.println(User.a);
//		System.out.println(User.b); 私有访问不了
//		System.out.println(User.c);  静态默认不能访问
//		System.out.println(User.d);继承权限,要么同包,要么有继承关系
        System.out.println(A.a);
//        System.out.println(A.b); 私有不能访问
        System.out.println(A.c);
        System.out.println(A.d);

	}

}

2.继承

2.1是什么

1. 继承

继承就是在已有类中派生出新的类,新的类能够吸收父类已有的属性和行为,并且还能扩展自己的属性和行为

2. 继承的特点

Java中只支持单继承, 不支持多继承, 这样可以使java的继承体系更加简单清晰

一个类中只能有一个父类, 但是一个类可以有很多的子类

继承关系是可以传递的

private私有化属性是不能被继承的

2.2能做什么

3. 解决什么问题

提高代码的复用 ,提高开发的效率

一个类如果没有显示继承另一个类那么该类就默认继承object

java.lang.object, 是java提供的跟类(祖宗),也就意味着 object中的属性是所有类都有的

2.3怎么用

语法: [修饰符] class 类名 extends 父类名{

类体;

}

package Extends;
/**
 * 1 继承 : 
 *   继承 就是在已有类中派生出新的类,新的类能够吸收父类已有的属性和行为,并且还能扩展自己的属性和行为
 *   
 *  2 继承特点
 *    java中 只支持单继承,不支持多继承 ,这样使java 的继承体系更加简单清晰
 *    		一个类只能有一个父类,但是一个类可以有很多子类
 *    继承关系是可以进行传递的
 *    
 *    private私有化属性不能被继承
 * 
 * 	3 解决什么问题?
 * 		提高 代码的复用,提高开发效率
 * 
 * 一个类如果没有显示继承另一个类,那么该类默认继承 Object
 * 		java.lang.Object ,是java提供的根类(祖宗) ,也就意味着 Object中的所有属性是所有类都有的
 * 
 * 4 怎么用
 * 		语法  [修饰符] class(子类) 类名 extends 父类名{
 * 				类体;
 * 		}
 * @author 人间失格
 * @data     2021年10月13日下午8:51:16
 */

public class Extends_01 {

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

}

3.super

3.1是什么

super : 官方说法是,代表了父类型特征,也可以理解为父类对象

通过子类中,可以使用super关键之,来标识父类,通过this来标识自己

3.2能做什么

1. 不能在静态上下文中使用

2. 用在构造方法或者成员方法中,区分子类和父类同名的变量和方法

super.xxx =xxx; 或者 super.m1();

3. 用在子类构造方法中,调用弗雷德构造方法

super(参数) : 必须出现在子类构造方法第一行

this(参数) : 也必须出现在第一行, 所以他们两个不能同时出现

如果构造方法第一行,没有出现 this (参数) 也没有出现 super(参数)

则默认有个super() 调用弗雷德无参构造

3.3怎么用

package Super;

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 Super;

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("子类构造");
    }
	

}

package Super;
/**
 * super : 官方给的说法是,代表了父类型特征,可以理解为父类对象
 * 		通过子类中,可以使用super关键字,来标识父类,通过this来标识自己
 * 
 * 1 不能再静态上下文中使用
 * 2 用在构造方法或者成员方法中 ,区分子类和父类同名的变量和方法
 * 		super.xxx = xxx;  super.m1();
 * 3 用在子类构造方法中,调用父类的构造方法
 * 			super(参数);   必须出现在子类构造方法第一行
 * 			this(参数) : 也必须出现在第一行,所以 他们两个不能同时出现
 * 		如果 构造方法第一行 , 没有出现 this(参数) 也没有出现 super(参数)  
 * 			则默认有个super()  调用父类的无参构造
 * @author 人间失格
 * @data     2021年10月13日下午9:13:08
 */
public class Super_01 {

	public static void main(String[] args) {
		SubClass sub = new SubClass();
		sub.test();
	}

}

3.4注意

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

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

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

package Super;

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

4. 覆写

4.1 是什么

override : 方法的覆写/重写

什么时候需要重写: 当父类功能无法满足子类需求的时候,子类需要根据需求对方法进行重写

方法覆写特指成员方法,只有成员方法可以被覆写,和静态方法,静态变量,成员变量都没有关系

4.2应用场景

什么时候需要重写: 当父类功能无法满足子类需求的时候,子类需要根据需求对方法进行重写

重写的必要条件:

1.必须有继承关系的体系中

2. 方法名必须一致,方法名不同,就是两个方法了,跟重写没有关系

3.参数列表必须一致,如果参数列表不一致,就是方法的重载(overload)

4. 返回值必须一致,返回值表示反馈的功能,不能更改功能

5. 不能比原方法有更宽泛的异常(错误不能越来越多)

6. 不能比原方法拥有更低的访问权限

重写的意义:
功能越来越强

错误越来越少

使用范围越来越广

覆写(override)和重载(overload)

package Override;

public class Override_01 {
	public static void main(String[] args) {
		//创建对象
		Cat c = new Cat();
		//调用对象
		c.move();
	}
}
//创建类 类名Animal
class Animal{
	public void move(){
		System.out.println("动物移动");
	}
}
//继承 子类cat父类Animal
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 修饰 ,常量名建议全部大写

5.3怎么用

常量

5.4深入final

package Final;
/**
 * 深入final : final 修饰的引用类型,地址不能更改, 和地址对因对应的数据,没有关系
 * @author 人间失格
 * @data     2021年10月13日下午10:02:23
 */
public class Final_02 {

		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;
		}
	}

Iiversse

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java 封装、继承、final、super、覆写

1.封装封装(计算机程序术语) 封装,即隐藏对象的属性和是实现细节,仅对外公开接口,控制在程序中的读和修改的访问级别;将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成"类",其中数据和函数都是类的成员。1.1packagepackage: 软件包机制限制的是编译之后的class文件的保存目录,和源文件无关 eclipse中,源文件也必须在这个目录中,这是eclipse的问题,和package无关 ...
复制链接

扫一扫