day_11_权限控制、继承、super、final、覆写

最新推荐文章于 2024-09-29 08:33:21 发布

势不可挡の内鬼

最新推荐文章于 2024-09-29 08:33:21 发布

阅读量61

点赞数

分类专栏：学习日志文章标签： java eclipse

本文链接：https://blog.csdn.net/m0_51589970/article/details/120751296

版权

学习日志专栏收录该内容

52 篇文章 0 订阅

订阅专栏

1. 封装

封装：控制用户对类的修改程度，隐藏属性和行为的具体实现，只提供公开的接口
简单来说，只让别人知道我能干什么而不知道我是怎么做的，也能够加强代码的安全性

1.1 package

限制的是编译之后的class文件的保存目录，和源文件无关， eclipse中，源文件也必须在这个目录中，这是eclipse的问题，和package无关，而Java中的package只是规定class文件
1.主要是为了解决命名冲突问题
   2.package语句必须在java源文件的第一行
   3.一般采用公司域名倒叙的方式
com.tledu.oa.system;
com.tledu.oa.pojo;
com.tledu.oa.dto;
域名倒叙.项目名.模块名
   4.带有package语句的java文件的编译方式
   javac -d 生成路径字符编码源文件路径
   javac -d ./ -encoding utf-8 xxxx.java
   -d : disk 磁盘
   ./ : 代表当前目录
   5.运行
   Java 包名.类名

1.2 Import

package _01_Package;

//导入对应的这个类
//.* 是导入对应包下的所有类
import java.util.*;

import com.User;
//java.lang.*; 下的所有类,为系统核心类,可以直接使用,不需要导入
//import用于导入当前类中需要用到的其他类，
//该语句必须在package语句之下,class语句之上
public class package_03 {
	public static void main(String[] args) {
	String str = "xxxx";
	/*
	 * 调用一个不是本包中的类，要写类全名
	 *注意：写代码的时候使用eclipse按空格会导入对应的包
	 *如果包导入错了也会报错
	 */
	User user = new User();
	user.m1();
	
	
}
}

1.3 权限控制

package PPP_01;

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

2. 继承

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

2.2 特点
   java中只支持单继承,不支持多继承 ,这样使java 的继承体系更加简单清晰
   一个类只能有一个父类,但是一个类可以有很多子类
   继承关系是可以进行传递的
   private私有化属性不能被继承

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

2.4 怎么用
   语法 [修饰符] class 类名 extends 父类名{
   类体;
   }

public class Extends_ {

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

}

package Extends;

public class Subclass extends Supclass {

	public void m2(){
		System.out.println("子类m2");
	}
}

package Extends;

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

3. super

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

3.1 不能再静态上下文中使用
3.2 用在构造方法或者成员方法中 ,区分子类和父类同名的变量和方法
       super.xxx = xxx; super.m1();
3.3 用在子类构造方法中,调用父类的构造方法
           super(参数); 必须出现在子类构造方法第一行
           this(参数) : 也必须出现在第一行,所以他们两个不能同时出现
           如果构造方法第一行 , 没有出现 this(参数) 也没有出现 super(参数)
           则默认有个super() 调用父类的无参构造

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. 覆写

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

  重写的必要条件
  1.必须有继承关系的体系中
  2.方法名必须一致 ,方法名不同,就是两个方法了,跟重写没有关系
  3.参数列表必须一致,如果参数列表不一致,就是方法重载
  4.返回值必须一致,返回值表示反馈的功能,不更改功能
  5.不能比原方法有更宽泛的异常(错误不能越来越多)
  6.不能比原方法拥有更低的访问权限

  重写的意义 :
   功能越来越强
   错误越来越少
   使用范围越来越广

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

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

5. final

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

  final修饰的类不能被继承
  final修饰的方法不能被覆写
  final修饰的变量不能二次赋值,并且没有默认值
  final修饰的静态变量,一般叫常量 , 一般使用 public static final 修饰,常量名建议全部大写

public class final_01 {
	//没有默认值会报错
//	final int a;
	final int i;
		final_01(int i){
			this.i = i;
			//不可二次赋值
//			this.i=i
		}
}
class MyMath{
	public static final double PI = 3.1415926;
}
//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() {
	// }
//}

5.1 深入final

package Final_;

//深入final : final修饰的引用类型,地址不能更改,和地址对应的数据 没有关系

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