java之7天继承,final,接口,抽象类

最新推荐文章于 2022-10-17 19:49:57 发布

麻辣小布叮

最新推荐文章于 2022-10-17 19:49:57 发布

阅读量771

点赞数 1

分类专栏：继承 final 接口抽象类

本文链接：https://blog.csdn.net/luobing_csdn/article/details/66969537

版权

final 同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

接口

1 篇文章 0 订阅

订阅专栏

抽象类

1 篇文章 0 订阅

订阅专栏

继承


/**
将学生和工人的共性描述提取出来,单独进行描述, 只要让学生和工人与单独描述的这个类有关系,就可以了.

继承:
1.提高代码的复用性
2.让类与类之间产生了关系, 有了这个关系类,才有了多态的特性..
*/

class Persion{

  String name;
  int age;
}

class Student extends  Person{
  //String name;
  //  int age;
void  study(

  System.out.println("goog study");
)

class Worker extends Person{
  //  String name;
//  int age;
  void work(){
   System.out.println("good work");
  }
}

}
/*
注意:千万不要为了获取其他类的功能,简化代码而继承, 必须是类与类之间有所属关系才可以继承,所属关系  is a.
*/

class A{
  void demo1(){}
  void demo2(){}
}

class B extends A
{
   //void demo1(){}  发现 B也有 demo2() 这个功能 说明不能乱继承,我们可以将 demo抽成出一个 父类 .但是 B 不能继承 A
   void demo3()}
}

/*
Java语言中,Java只支持单继承,不支持多继承.
因为多继承 容易带来安全隐患.
当功能内容不同时,子类对象不确定要运行那个
但是java保留了这种机制,并用另一种体现形式来完成,多实现
*/
class A{

 void show(){ 
   System.out.println("A");
  }
}

class B{

 void show(){ 
   System.out.println("B");
  }
}

class C extends A,B{

 public statiac void main(String [] args){

    C  c=new C();
    c.show();  //如果出现多继承  此时就不知道是打印 A 还是　B　所以java不支持多继承.　
 }
}


/*
要先使用体系,先查阅体系父类的描述,因为父类中定义了该体系中共性功能.
通过了解共性功能,就可以知道该体系的基本功能

在具体调用时,要创建最子类的对象,为什么呢?
1:一是因为有可能父类不能创建独享
2.创建子类对象可以使更多的个功能,包括基本的也包括特有的
*/

//聚集 : has a 分为下面两种

1.聚合: 球队和球员 (球队少一个球员没有什么大的问题)
2.组合: 手是人体一部分 (实物联系更紧密)

//子类父类中的成员的特点
类中的成员
1.变量
2.函数
3.构造函数

//不同的变量


class Fu{
  int num1=4;

}

class Zi extends Fu{
  int num2=5;
}


class  ExtendsDemo{

  Zi z=new Zi();
  System.out.println(z.num1+"...."+z.num2);  //  4....5
}

//相同的变量


class Fu{
  int num1=4;

}

class Zi extends Fu{
  int num1=5;
}


class  ExtendsDemo{

  Zi z=new Zi();
  System.out.println(z.num1+"...."+z.num1);  //  5....5
}

//子类中的方法


class Fu{
 /*private*/  int num1=4;

}

class Zi extends Fu{
  int num1=5;

  void show(){
     System.out.println(this.num1);   //this 表示本类对象的引用   输出  5
     System.out.println(super.num1):  //super表示父类对象的引用  输出  4,如果num为private 不能使用 num
  }
}


class  ExtendsDemo{

  Zi z=new Zi();
  z.show();

//  5  4
}

//如果子类中没有和父类相同的变量那就 this=suuper 中的变量


class Fu{
  int num=4;  
}
class Zi extends Fu{
	//int num=5;
	void show(){
		
		System.out.println(this.num);
		System.out.println(super.num); //
		
	}
	
}

public class day7_T1 {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Zi z=new Zi();
  
			z.show();
               //   4  4 
	}

}

//父子类中函数的特点


class Fu{
 void show1(){
   System.out.println("fu show");	 
 }
}
class Zi extends Fu{
	
	void show2(){
		System.out.println("zi show");
		
	}
	
}
public class day7_T1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Zi z=new Zi();
			z.show1();
			z.show2();
	}
//输出  
fu show
zi show
}

//父子类函数名相同



/*
当子类和父类出现一模一样的函数时
当子类对象调用该函数的时候,会运行子类函数的内容
如同父类的函数被覆盖一样

这种情况是函数的另一种特性  : 重写(覆盖,可以发现 重写 发生在子类和父类之间 ,函数每个部分完全相同)

当子类继承父类的时候,子类就会沿袭父类的所有公共成员.
*/
class Fu{
 void show(){
   System.out.println("fu show");	 
 }
}
class Zi extends Fu{
	
	void show(){
		System.out.println("zi show");
		
	}
	
}
public class day7_T1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Zi z=new Zi();
			z.show();
	}
       //zi show
}

//重写的特性2


//可以看出 适合后期程序的升级 和 扩展

// 重写可以保留父类的功能定义,并可以重写功能的内容.

class Fu{
 void show(){
   System.out.println("fu show");	 
 }
}
class Zi extends Fu{
	
	void show(){
		System.out.println("zi show");
		super.show();  //还可以继续使用父类的函数 或其他成员
	}
	
}
public class day7_T1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Zi z=new Zi();
			z.show();
	}
}

//注意事项


//重写 (覆盖)

1. 子类覆盖父类,必须保证子类权限大于等于 父类权限 ,才可以覆盖,否则编译失败
2. 静态只能覆盖静态.

重写: 父子类方法要一模一样  包括返回值
重载: 只看同名函数的参数列表


//注意下面不是重写 

class Fu{
 private void show(){
   System.out.println("fu show");	 
 }
}
class Zi extends Fu{
	
	void show(){  //这里没有重写  ,因为 子类根本就不知道父类有 show 这个防范
		System.out.println("zi show");
		//super.show();  //还可以继续使用父类的函数 或其他成员
	}
	
}
public class day7_T1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Zi z=new Zi();
			z.show();
	}
}

//父子类中的构造函数特点


//父子类中 构造函数 不是重写 因为  方法名不同

class Fu{
  Fu(){
	  System.out.println("fu run");
  }
}
class Zi extends Fu{
	
	Zi(){
//super();  默认 在第一行 有这个 语句 调用父类 .
		System.out.println("zi run");
	}
	
}
public class day7_T1 {
	public static void main(String[] args) {
			Zi z=new Zi();
	}
}
//输出 
fu run
zi run 

//说明 在初始化子类的时候 先加载父类 然后加载子类    

继续证明上面的观点--接下来看看 
class Fu{
	static{  //静态代码块    只要该类被JVM 加载到内存 就会运行这个 里面的内容 
		System.out.println("fu static run");
	}
	
	{  //构造代码块  在所有 构造函数前都会运行 ,除非不用构造函数 
		System.out.println("fu gouzao run");
	}
	
  Fu(){
	  System.out.println("fu run");
  }
}
class Zi extends Fu{
	static{
		System.out.println("zi static run");
		
	}
	
	{
		System.out.println("zi gouzao run");
	}
	
	Zi(){
		//super(); 默认都有  这行
		System.out.println("zi run");
	}
	
}
public class day7_T1 {
	public static void main(String[] args) {
			Zi z=new Zi();
		
	}
}

//输出
fu static run
zi static run
fu gouzao run
fu run
zi gouzao run
zi run

//子类中所有的构造方法的第一行都会默认有 super() 这行可以显示调用和可以省略
(因为初始化的过程必须先做.只有做了,子类才能使用父类成员)


class Fu{
	static{  //静态代码块    只要该类被JVM 加载到内存 就会运行这个 里面的内容 
		System.out.println("fu static run");
	}
	{  //构造代码块  在所有 构造函数前都会运行 ,除非不用构造函数 
		System.out.println("fu gouzao run");
	}
  Fu(){
	  System.out.println("fu run");
  }
  Fu(int x){  //如果不调用该类中的这个构造方法 就不会被运行
	  System.out.println("fu run"+x);
  }
}
class Zi extends Fu{
	static{
		System.out.println("zi static run");
		
	}
	{
		System.out.println("zi gouzao run");
	}
	Zi(){
		//super(); 默认都有  这行
		System.out.println("zi run");
	}
	Zi(int x){
		//super(); 默认都有  这行
		System.out.println("zi run"+x);
	}
	
}
public class day7_T1 {
	public static void main(String[] args) {
			Zi z=new Zi(4);
		
	}
}
//输出 
fu static run
zi static run
fu gouzao run
fu run
zi gouzao run
zi run4

//为什么子类一定要访问父类中的构造函数??


class Person{
	String name;  //默认为0  
	
	 //Perseon(){} 显示写出 默认构造函数 
	
	Person(String name){  //发现 我们没有写 那个默认的构造函数 
		this.name=name;
		System.out.println("fu run"+this.name);
	}
}

class Student extends Person{
	
	Student(){
		//super();   报错  因为 父类中 没有显示写出构造函数,而出现了其他构造函数,一般我们建议将 类的默认构造函数显示写出来.
		super("xx");  //如果没有写父类默认构造函数 ,只能调用 其他构造函数
		System.out.println("zi run");
		//super("xx"); 写这里也报错 super 必须放在第一行 .
	}
	
	Student(String name){
		//super(); 这里也不能写 
		super(name);
		System.out.println("zi run" +this.name); //如果不调用父类的构造函数 我们就拿不到这个值了.
	}
	
}

public class day7_T2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student stu=new Student();
               System.out.println(new Person("xx").name);
	}

}

//输出
fu runxx
zi run
fu runxx
xx

只要子类继承了父类,就可以沿袭父类中所有公共成员, 既然 需要使用到 父类的成员 ,所以父类 必须要先实例化.必须先加载 ,所以 super只能放在第一行 ,这样就是为了后面的子类能使用其父类中的成员.

上面由于只写了一个有参数构造函数 ,所以下面 的Student 只能都调用 那个有参数的构造函数.

//this 和super 的关系 (一样的用法)


class Person  /*extends Object*/{
	String name;  //默认为0  
	
	 //Perseon(){} 显示写出 默认构造函数 
	
	Person(String name){  //发现 我们没有写 那个默认的构造函数 
		this.name=name;
		System.out.println("fu run"+this.name);
	}
}

class Student extends Person{
	
	Student(){
		super("xx");  //如果没有写父类默认构造函数 ,只能调用 其他构造函数
		System.out.println("zi run");
	}
	
	Student(String name){
		this();  //调用子类自己的  默认构造函数 由于 上面的构造函数 中调用 super("xx") 所以这句话可以了
		//super();  // 发现 写了this()后 这句报错了, 因为  super 要在第一行 
		//this();  //发现 先写 super后 在写 this() 也不行    因为  构造函数中 只能调用一次 父类构造方法 ,而且 super要放在第一行 ,所以这两个不能同时出现
		System.out.println("zi run" +this.name); //如果不调用父类的构造函数 我们就拿不到这个值了.
	}
	
}

public class day7_T2 {
	public static void main(String[] args) {
		Student stu=new Student("aa");
	}

}

//发现  this() 和 super() 不能同时出现在子类的构造函数中.
this() 可以代替super()  因为  this()中 也有 super() 这个语句

//final: 最终,作为一个修饰符
1.可以修饰类, 函数 ,变量
2.被final修饰的类不可以继承,(避免 ,子类继承父类后,将父类里面功能该个面目全非)
3.被final修饰的方法不可以重写 (如果某个类中一些方法可以重写,有些不行)
4.被final修饰的变量是一个常量 ,只能赋值一次, 即可以修饰成员变量,也可以修饰局部变量.(常量建议都全大写,多个单词间使用 "_" 下划线连接)

当描述事物的时候一些数据的出现值是固定的,那么这是为了增强阅读性,都给这个值起个名字,方便阅读,而这个值不需要改变,所以就加上final

5.内部类定义在该类的局部位置上时,只能访问该具备被final修饰的局部变量


class /*final*/ ArraySort{
	
	final static int NUMBER=9; //终身为 5
	final double PI_VALUE=3.14;  //常量
	
	/*final*/ void intSort(int[] arr){  //修饰方法
                  final int INDEX=5;  //终身为 5
		System.out.println("int 类型的数组 开始排序....");
		//功能代码前面的例子有
	}
	
}

class  SubSort extends ArraySort{
	void intSort(int[] arr){  //如果 父类方法 被修饰后  这句就报错了
		System.out.println("haha");  //被子类 重新出来 haha 了   失去了原有数组排序功能. 此时就只有 使用 final了 防止 其他类来重新类中的方法.
	}
	
}

抽象类


/**
 * 当多个类中初相相同功能,但是功能主体不同,这时候可以进行向上抽取,只抽取功能定义,而不定义主体.
 * 
 * 抽象 :看不懂
 * 1.抽象方法一定在抽象类中
 * 2.抽象方法和抽象类都必须被abstract关键字修饰
 * 3.抽象类不可以用new 创建对象,因为调用抽象方法没有意思
 * 4.抽象类中的抽象方法要被使用,必须由子类复写所有的抽象方法,建立子类对象调用.
 *   如果子类只覆盖部分抽象方法,那么子类还是一个抽象类.
 * 
 * 抽象类和一般类没有太大的不同
 * 该如何描述事物,就如何描述事物,只不过,该事物出现一些不太明确的行为.juic
 * 这些不确定的部分,也是该事物的功能,需要明确出现,但是无法定义主体.
 * 通过抽象方法来表示 
 * 
 * 抽象类比一般类多个抽象函数
 * 抽象类不可以实例化
 * 抽象类中可以不定义抽象方法
 * 
 * abstract 只能修饰 类和方法 不能修饰 变量
 * 还可以不让该类建立对象.
 */
abstract class Students{
	abstract void study();/*{
	System.out.println("study");  //如果子类 的行为不一样 这个方法就没有用了
}*/
}

class BaseStudent extends Students{
	
	void study(){
		System.out.println("base study");
	}
}

class AdvanceStudent extends Students{
	void study(){
		System.out.println("advance study");
	}
}

//案例2 采用抽象设计


/**
 * 假如我们在开发一个系统是需要对员工进行建模,
 * 员工包含3个属性, 姓名,工号,工资 
 * 经理也是员工,除了员工外还有奖金属性
 * 使用继承的思想设计出员工累和经理类,要求类中提供必要的方法进行属性访问.
 */
abstract class Employee{
	
	private String name;
	private String id;
	private double salary;  //工资
	
	public Employee(String name, String id, double salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}
	
	abstract void work();
}
class Professional extends Employee{ //专业人士
	public Professional(String name, String id, double salary) {
		super(name, id, salary);
	}

	@Override
	void work() {
		System.out.println("professional work");
	}
}

class Manager extends Employee{ //管理员
	private int bonus;  //奖金
	public Manager(String name, String id, double salary,int bonus) {
		super(name, id, salary);
		this.bonus=bonus;
		// TODO Auto-generated constructor stub
	}
	@Override
	void work() {
		System.out.println("manager work");
		
	}
	
}

//例子类



/**
 * [====模版方法设计模式===]
 * 1.在定义功能时候,功能的一部分是确定的,但是一部分是不确定,而确定的部分在使用不确定的部分,
 *  那么这时就将不确定的部分暴露出去,由该类的子类去完成.
 *  
 * 
 * 需求: 获取一段程序运行的时间
 * 原理: 获取程序开始和结束的时间差就可以了
 * 下面经过 三不变形 就成了 一个模版了
 */
abstract class GetRunTime{
	
	public final void getTime(){ //不想子类 把这个方法的功能给改了
		long start=System.currentTimeMillis();  //固定代码
		
		//封装这段代码的运行时间 ,如果代码段换了呢 
	/*	for (int i = 0; i < 1000; i++) { 
			System.out.println(i);     
		}*/
		runcode();                             //不固定代码  
		
		long end=System.currentTimeMillis(); //固定代码
		System.out.println("毫秒:"+(end-start));  //固定代码
		
	}
	public abstract void runcode();/*{
		for (int i = 0; i < 1000; i++) {
			System.out.println(i);   
		}
	}*/
	
	
}

class SubTime extends GetRunTime{
	@Override
	public void runcode() {
		for (int i = 0; i < 4000; i++) {  //变成 4000次
			System.out.println(i);
		}
	}
}


public class TemplateDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//GetRunTime grt=new GetRunTime();
		//grt.getTime();
		
		SubTime st=new SubTime();
		st.getTime();
	}

}

//接口


/**
 *接口:  初期的理解,可以认为是一个特殊的抽象类
 *   当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示
 *  
 * class: 用于定义类
 * interface:用于定义接口
 * 
 * 接口定义时,格式特点:
 * 1.接口中的常见定义,常量,抽象方法.
 * 2.接口中的成员都有固定修饰符
 *    常量:public static final 
 *    方法:public abstract  不能为 static的 
 *    
 * 接口: 是不可以创建对象, 因为有抽象方法 ,所以接口是一个特殊的抽象类
 * 需要被子类实现,子类对象接口中的抽象方法全部复写,子类才可以实例化,否则子类也是一个抽象类
 * 
 * 接口可以被类多实现.
 * java不提供 多继承  ,变成了多实现
 * 
 * 1.类      和      类的关系       继承 
 * 2.类      和     接口               实现 
 * 3.接口  和    接口                继承  
 *
 */
interface Inter{
	public static final int NUM=3;  //public static final 可省略
	public abstract void show();    //public abstract 可省略
}

interface InterA{
	public abstract void method();    //public abstract 可省略
	public abstract void show();   //没有方法主体,所以由子类自己定义主体
}

class Demo{
	public void function(){}  //
	
}

//继承一个父类 实现两个接口
class Test extends Demo implements Inter,InterA{

	@Override
	public void show() {  //股改了两类中的 show 方法
		System.out.println(this.NUM);
		//System.out.println(super.NUM);  //报错
	}

	@Override
	public void method() {
		System.out.println(Inter.NUM);
	}
}


public class InterfaceDemo {
	public static void main(String[] args) {
		Test test=new Test();
		System.out.println(Inter.NUM);  //3
		System.out.println(test.NUM);   //3 
		System.out.println(Test.NUM);   //3
		
		// test.NUM=4; //是常量所以值不能被覆盖
	}
}

//接口间关系




interface A{
	public abstract void show1();
	int show();
}
interface B extends A{  //  b 有两个方法了
	public abstract void show2();

	//boolean show(); 继承的接口中不能很出现这个情况   
}
interface C extends B{ //  c 有三个方法了
	public abstract void show3();
}

class InterRelation implements C{
	@Override
	public void show2() {}

	@Override
	public void show1() {}

	@Override
	public void show3() {}

	@Override
	public int show() {
		// TODO Auto-generated method stub
		return 0;
	}
}

//接口间的多继承



interface D{  //  因为  A E中没有 方法体 就不冲突
	public abstract void show4();
}
interface E { //  c 有三个方法了
	public abstract void show5();
}

interface F extends D,E{  //因为 D E中没有 方法体 就不冲突
	public abstract void show6();
}

//接口特点



/**
 * 接口的特点
 * 1.接口是对外暴露的规则
 * 2.接口是程序的功能扩展
 * 3.接口可以用来实现
 * 4.类和接口是实现的关系,而类可以继承一个类的同时实现多个接口
 * 5.接口和接口之间有多继承关系
 * 6.降低了耦合性.
 * 
 * 
 * 案例: 学生的行为
 *   
 * 继承 :  一般包含基本功能        is     (你是我 是 其中的一个)
 * 接口 : 一般用于定义扩展功能    like   (你像  我中的一个)
 */

abstract class StudentParent{
	//基本功能 定义在类中 
	abstract void study();
	void sleep(){
		System.out.println("sleep");
	}
	
	/*abstract void smoking(){//由于 又不是每个人都抽烟怎么办呢 ??
		System.out.println("我吸的XX牌子的烟");
	}*/
}
interface smoker{  //扩展功能 定义在接口中 
	void smking();
}

interface Wine{  //扩展功能 定义在接口 
    void drink();	
}

//学生 张三  除了学生外  还学会 抽烟喝酒
class ZhangSan extends StudentParent implements smoker,Wine{

	@Override
	void study() {}
	
	@Override
	public void smking() {}

	@Override
	public void drink() {}
}