day11_继承、super

最新推荐文章于 2024-10-16 10:13:45 发布

coderbr

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量86

点赞数

分类专栏： Java 文章标签： eclipse java

本文链接：https://blog.csdn.net/qq_43562097/article/details/120752495

版权

Java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

本文介绍了Java中的包机制，包括其作用、创建与使用规则。接着讲解了继承的概念，强调了Java中的单继承特性，并阐述了继承的意义和super关键字的使用。此外，还讨论了权限修饰符，如public、private、默认和protected，以及它们在继承中的影响。最后，提到了方法重写（Override）的条件和意义，以及final关键字在类、方法和变量上的应用。

摘要由CSDN通过智能技术生成

day11_继承、super

Package

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 包名.类名
```

注意：

调用一个不是本包中的类，需要写类全名 包名.类名

静态导入

//User类
package _01_Package.com;

public class User {
	public static int a = 1;
	public void m1() {
		System.out.println("成员方法");
	}
}


package _01_Package;

import _01_Package.com.User;

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

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

权限修饰符

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

继承

1 继承 :
继承就是在已有类中派生出新的类,新的类能够吸收父类已有的属性和行为,并且还能扩展自己的属性和行为
2 继承特点
java中只支持单继承,不支持多继承 ,这样使java 的继承体系更加简单清晰
一个类只能有一个父类,但是一个类可以有很多子类
继承关系是可以进行传递的
private私有化属性不能被继承
3 解决什么问题?
提高代码的复用,提高开发效率
一个类如果没有显示继承另一个类,那么该类默认继承 Object
java.lang.Object ,是java提供的根类(祖宗) ,也就意味着 Object中的所有属性是所有类都有的
4 怎么用

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

	public class Extends_01 {
		public static void main(String[] args) {
			SubClass subClass = new SubClass();
			// 调用继承自父类的方法
			subClass.m1();
			// 调用自己的方法
			subClass.m2();
			// 因为所有类都直接间接继承Object,而toString就是Object中的方法
			// 至于toString是干什么的,回来再说
			subClass.toString();
		}
	}
	
	package _03_Extends;
	
	public class SubClass extends SupClass {
		public void m2(){
			System.out.println("子类m2");
		}
	
	}
	
	
	package _03_Extends;
	
	public class SupClass {
		public void m1(){
			System.out.println("父类m1");
		}
	}

super

super : 官方给的说法是,代表了父类型特征,可以理解为父类对象
通过子类中,可以使用super关键字,来标识父类,通过this来标识自己
注意：
1 不能再静态上下文中使用
2 用在构造方法或者成员方法中 ,区分子类和父类同名的变量和方法
super.xxx = xxx; super.m1();
3 用在子类构造方法中,调用父类的构造方法
super(参数); 必须出现在子类构造方法第一行
this(参数) : 也必须出现在第一行,所以他们两个不能同时出现
如果构造方法第一行 , 没有出现 this(参数) 也没有出现 super(参数)
则默认有个super() 调用父类的无参构造

构造方法私有化之后,不能被继承,因为子类构造方法中,需要调用父类构造方法
但是因为私有化的问题,导致子类调用不了

例题：

public class Super_03 {
	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("父类构造");
}
}

结果为 : 父类静态语句块,子类静态语句块,父类实例语句块,父类构造,子类实例语句块,子类构造

方法重写（Override）

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

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("动物移动");
		}
	}
	class Cat extends Animal{
		// @Override注解 标识该方法是覆写的父类的方法
		// 如果加着该注解,方法如果不小心写错了,比如方法名拼写错误的时候,会提示有错
		@Override
		public void move() {
			System.out.println("猫............在爬");
		}
	}

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{
	//final修饰的静态变量,一般叫常量 , 一般使用 public static final 修饰,常量名建议全部大写
		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() {
		// }
	//}

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;
}
}
//final : final修饰的引用类型,地址不能更改,和地址对应的数据 没有关系