5.继承、抽象类、接口

最新推荐文章于 2021-12-14 13:57:24 发布

'小手冰凉

最新推荐文章于 2021-12-14 13:57:24 发布

阅读量148

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/m0_49585228/article/details/107561728

版权

笔记专栏收录该内容

34 篇文章 0 订阅

订阅专栏

继承、抽象类、接口

5.1什么是继承？如何完成一个继承关系？
继承
1.面向对象的特征之一。[封装，继承，多态]
2.继承是一种通过现有的类，创建出新类的机制。
3.继承实际上一种类与类之间关系。

继承是一种通过现有的类，创建出新类的机制。
父类—现有的类【已经存在的】。
子类—创建出来的新类。
子类可以得到父类中的部分变量和方法。
如何完成一个继承关系：
通过extends关键字实现继承关系
格式：
访问限制修饰符 class 子类的类名 extends 父类的类名{

}

//现有的类
public  class  Person{

}
//创建Person的子类
public   class   Student   extends   Person{

}

Person类就是父类
Student类就是子类
5.2子类对象创建过程？
子类对象在创建的时候，默认要调用父类无参数的构造方法

package com.click369.test1;
/**
 * Person类充当了父类
 * @author Administrator
 *
 */
public class Person {

	public  Person(){
		System.out.println("Person类的无参数构造方法");
	}
	
	public  Person(String value){
		System.out.println("Person类的有参数构造方法");
	}
}

package com.click369.test1;
/**
 * Student类就是子类
 * @author Administrator
 *
 */
public class Student extends Person{

	public Student(){
		System.out.println("Student子类的无参数构造方法");
	}
}
Student  stu1=new Student();

5.3 Java中子类的继承性？
可以在子类的构造方法中用super关键字，调用父类中的任意一个构造方法来执行

/**
 * Person类充当了父类
 * @author Administrator
 *
 */
public class Person {

	public  Person(){
		System.out.println("Person类的无参数构造方法");
	}
	
	public  Person(String value){
		System.out.println("Person类的有参数构造方法,参数是value=="+value);
	}
	
	public  Person(int value){
		System.out.println("Person类的有参数构造方法,参数是value=="+value);
	}
}

package com.click369.test1;
/**
 * Student类就是子类
 * @author Administrator
 *
 */
public class Student extends Person{

	public Student(){
		//super(); //调用父类无参数构造方法
		super("Student");
		System.out.println("Student子类的无参数构造方法");
	}
}
Student  stu1=new Student();

总结：子类对象在创建的时候，总是会先调用父类的构造方法创建出父类对象，然后在执行子类的构造方法，创建出子类对象。可以使用super关键字让子类调用指定的父类的构造方法创建父类对象。
5.4 java中的访问限制修饰符？
访问限制修饰符就是用来限定java元素【类，变量，方法，接口…】,在哪些情况下可以访问，哪些情况不能访问。【保护隐私】
访问限制修饰符分别有：
public【公共的】 private【私有的】 protected【受保护的】缺省的【友好的】
1.public【公共的】任何元素都可以访问 [类，变量，方法，接口]
2.private【私有的】创建者自己可以访问，其他的元素不能访问 [变量，方法]
3.protected【受保护的】与创建者有关系【继承】的可以访问，没有关系的其他元素不能访问[变量，方法]
4.缺省的【友好的】什么都不写同一个包中可以访问，不同包就不能访问[类，变量，方法，接口].
类上面可以使用public【公共的】和缺省的访问修饰符。
1.被public修饰的类，可以在任何地方被访问。
2.被缺省的修饰符修饰的类，只能被同一个包中其他类访问，跨出包就不能访问。
在这里插入图片描述

5.5 java中的包？
1.为了方便管理java类。在开发应用程序的时候，会编写很个多类，而类多了之后就不利于管理，因此就有了程序包，我们把功能相似的类放入一个包中，这样就可以方便管理。
2.为了区分名称相同的类。通过该类隶属于不同的包，来区分名称相同的类。
3.包的创建语句所出现的位置在类的首行。
4.格式：package 包名;
例如：package com.click369.test2;

5.包名的名称规则：
1.合法的标识符
2.由多个合法标识符组成，中间通过【.】分割
3.不能有大写和空格 Com.Baidu–错误
4.公司域名倒置+项目名称【简写】+功能名称
例如: com.baidu.map.test 、 com.baidu.image.service 、com.github.wxpay.sdk
com.baidu.map.test—百度公司的地图项目的测试包
com.baidu—公司域名倒置
map—项目名称【简写】
test—功能名称
5.在使用某个包中的类的时候，需要通过import引入类所在的包
（1）类中创建包的语句与定义类的语句之间，通过import引入类所在的包的语句
（2）Java.lang包系统会自动引入，我们就不需要手动通过import关键字引入，除过Java.lang包其他的包都是需要import关键字引入。
（3）通常情况下是import 包名+类名; 【只引入这个包中的这个类】
例如：import com.click369.test1.TestClass1;
（4）通常情况下是import 包名.; 【将指定包中的所有类全部引入】
例如：import com.click369.test1.;
6.在Exlipse开发工具中通过【Ctrl+Shift+o】自动导包。

package com.click369.test1;
public class TestClass {
	public String pub_str="TestClass公共的";
}
package com.click369.test1;

public class TestSonClass extends TestClass{
	//在子类中，自己定义的成员变量与继承自父类中的某一个成员变量名称相同
	public  String  pub_str="zhangsan";
	
	public  void  test1(){
		System.out.println("pub_str=="+pub_str);
		System.out.println("pub_str=="+super.pub_str);
	}
}

5.6成员变量的隐藏和方法重写？
成员变量的隐藏
1.在同一个类中，局部变量的名称与成员变量的名称相同。可以通过this.成员变量名称，强制调用，被隐藏的成员变量值。
2.在子类中，自己定义的成员变量与继承自父类中的某一个成员变量名称相同。可以通过super.成员变量名称，强制调用，被隐藏的成员变量值

package com.click369.test1;
public class TestClass {
	public String pub_str="TestClass公共的";
}
package com.click369.test1;

public class TestSonClass extends TestClass{
	//在子类中，自己定义的成员变量与继承自父类中的某一个成员变量名称相同
	public  String  pub_str="zhangsan";
	
	public  void  test1(){
		System.out.println("pub_str=="+pub_str);
		System.out.println("pub_str=="+super.pub_str);
	}
}

方法重写
1.方法重载—在同一个类中方法名称相同，参数不同。
2.方法重写—在子类中自己定义的一个方法，与从父类中继承的方法一模一样，这时子类重写了父类的方法。可以通过super.方法名称，强制调用继承自父类的方法。

package com.click369.test1;
public class TestClass {	
	public  void testMethod(){
		System.out.println("TestClass类的testMethod");
	}
}

package com.click369.test1;

public class TestSonClass extends TestClass{	
	//在子类中自己定义的一个方法，与从父类中继承的方法一模一样，这时子类重写了父类的方法。
	public  void testMethod(){
		System.out.println("TestSonClass类的testMethod");
	}
	
	public  void  test1(){
		testMethod();
		super.testMethod();
	}
}

super关键字
this – 出现在哪一个类中表示当前这个类的对象。【调用本类中的变量和方法】
super出现在哪一个类就表示该类的父类对象【用来在子类调用父类中的变量和方法】
5.7上转型对象的含义和特征？
子类对象赋值给父类变量—上转型对象

package com.click369.test3;
public  class TestClass {
	public  String  getInfo(){
		return "父类的实例方法";
	}
}

package com.click369.test3;
public class SonClass extends TestClass{
	public  String  info(){
		return "子类的实例方法";
	}
}

package com.click369.test3;
public class TestMain {

	public static void main(String[] args) {
		//t1里面保存了父类的对象
		TestClass  t1=new TestClass();
		//父类的对象只能调用父类的方法
		System.out.println(t1.getInfo());
		//s1里面保存了子类的对象
		SonClass  s1=new SonClass();
		//子类的对象可以调用子类自己定义的方法
		System.out.println(s1.info());
		//子类的对象也可以调用从父类继承的方法
		System.out.println(s1.getInfo());
		//上转型对象--子类对象赋值给父类变量
		TestClass  t2=new SonClass();
		//上转型对象,只能调用被子类继承的方法，子类自己的方法就无法调用
		//如果需要上转型对象调用子类自己的方法，将上转型对象强制转换成子类对象
		SonClass s2=(SonClass)t2;
		System.out.println(s2.info());
		System.out.println(t2.getInfo());	
	}
}

5.8 什么是抽象类？为什么使用抽象类？抽象类中的元素？抽象类的使用？
抽象类：抽象类也是一个类class，使用abstract关键字修饰的类
格式：访问限制修饰符 abstract class 类名{}
public abstract class TestClass{
}

为什么使用抽象类？
提供可由子类实现的公共形式，子类根据自身的特点，按照自己的意图重写构造这个公共形式。

抽象类中的元素
1、抽象类也是一个类，它可以有实例变量，类变量，构造方法，实例方法，类方法，【抽象方法】
2.抽象方法–用abstract关键字修饰，没有方法体，能出现在抽象类中。抽象是不能用final修饰的。

package com.click369.test1;
public abstract class TestClass {
	public  int testid=1001;
	public static String  testname="抽象类";
	
	public TestClass(){
		System.out.println("抽象类TestClass的构造方法");
	} 
	
	public  void   testMethod(){
		System.out.println("抽象类中的实例方法");
	}
	
	public static  void   testStaticMethod(){
		System.out.println("抽象类中的类方法");
	}
	//抽象方法
	public  abstract  void  test11();
}

抽象类的特点：
1.抽象类不能new,可以通过上转型对象构造出抽象类的对象。
2.当一个普通的java类继承一个抽象类以后，要重写抽象类中的抽象方法，否则将这个普通的java类会重写该成抽象类的抽象方法。
3.抽象类可以继承抽象类。
4.抽象类中可以有抽象方法，也可以一个抽象方法都没有。
5.抽象类对象调用抽象方法，实际上是在调用被子类重写以后的方法。

package com.click369.test1;

public abstract  class TestClass {

	public  int testid=1001;
	public static String  testname="抽象类";
	
	public TestClass(){
		System.out.println("抽象类TestClass的构造方法");
	} 
	
	public  void   testMethod(){
		System.out.println("抽象类中的实例方法");
	}
	
	public static  void   testStaticMethod(){
		System.out.println("抽象类中的类方法");
	}
	//抽象方法
	public  abstract  void  test11();	
}

package com.click369.test1;

public class SonClass extends TestClass{

	
	public void test11() {
		
	}
}

/*
public  abstract  class SonClass extends TestClass{

}
*/

package com.click369.test1;

public class TestMain {

	public static void main(String[] args) {
		//1.抽象类不能创建对象。
		//TestClass  t1=new TestClass();
		//2.通过上转型对象构造出抽象类的对象
		TestClass  t2=new SonClass();
	}
}

实例：农场生产水果，有苹果，草莓，橘子，消费者可以根据自己的选择吃到对应的水果。
package com.click369.test1;

public abstract class ShuiGuo {
	public abstract void  eat();
}

package com.click369.test1;

public class PingGou extends ShuiGuo{

	public void eat() {
		 System.out.println("啊呜！啊呜！吃苹果");
	}

}
package com.click369.test1;

public class CaoMei extends ShuiGuo{

	public void eat() {
		System.out.println("啊呜！啊呜！吃草莓");
	}

}
package com.click369.test1;

public class JuZi extends ShuiGuo{

	public void eat() {
		System.out.println("啊呜！啊呜！吃橘子");
	}

}
package com.click369.test1;
/**
 * 农场
 * @author Administrator
 *
 */
public class NongChang {
	//买水果
	public  static  ShuiGuo sellShuiGuo(String name){
		ShuiGuo  sg=null;
		if(name.equals("苹果")){
			sg=new PingGou();
		}
		if(name.equals("草莓")){
			sg=new CaoMei();
		}
		if(name.equals("橘子")){
			sg=new JuZi();
		}
		return sg;
	}
}

package com.click369.test1;

import java.util.Scanner;

public class TestMain {

	public static void main(String[] args) {
		System.out.println("本农场有水果苹果，草莓，橘子");
		System.out.println("想吃什么");
		Scanner  read=new Scanner(System.in);
		String name=read.nextLine();
		ShuiGuo  sg=NongChang.sellShuiGuo(name);
		sg.eat();
	}
}

抽象类的意义：
提供可由子类实现的公共形式，子类根据自身的特点，按照自己的意图重写构造这个公共形式。
优点：可以结构化我们的程序，达到代码重用的效果。
5.9 什么是接口？为什么使用接口？接口中的元素？接口的使用？
接口：
接口本质与抽象类相似，都是提供可由子类实现的一般形式[公共形式]，实现接口的子类可以根据自身的特点来扩展一般形式[公共形式]。

为什么使用接口？
因为在java中所有的继承关系都是单继承关系。也就是说一个类只能有一个父类，不能一个类同时继承多个类。为了克服这种单继承关系，所以才用接口。那么也就是说接口是可以被同一个类去实现多个。

接口中的元素
1.接口中所有的变量都是public static final修饰的类变量,可以省略public static final修饰符
2.接口中可以有类方法【jdk8.0开始接口被增强可以有静态方法、接口默认方法】
3.接口中可以有抽象方法，所有的抽象方法都是public abstract,可以省略public abstract
4.接口中的所有的元素都是public修饰符修饰的，除过接口默认方法。

package com.click369.test3;

public interface MyInterface {
	//1.接口中所有的变量都是public static  final修饰的类变量,可以省略public static  final修饰符
	int  num=100;
	public  String  name="zhangsan";
	public static String  address="xian";
	//2.接口是没有构造方法
	//public MyInterface(){}
	//3.接口中没有是实例方法
	//public  void  testMethod(){}
	//4.接口中可以有类方法【jdk8.0开始接口被增强可以有静态方法、接口默认方法】
	public static void  testMethod(){}
	//5.接口中可以有抽象方法，所有的抽象方法都是public  abstract,可以省略public  abstract
	public  abstract void  abstractMethod();
	void  abstractMethod1();
}
//接口中的元素
final修饰的类变量
Static修饰的类方法
public  abstract抽象方法
因为接口中的所有的元素都是public修饰符修饰的，因此上接口继承接口以后，会将父接口中的所有元素全部继承【全继承】
//接口可以继承接口，并且是全继承【接口中中的元素都是public】
public interface TestInterface extends MyInterface{

}

接口的使用：
通过让类使用implments关键字去实现这个接口，或者多个接口。如果有多个接口中间使用“,”分割。

public   interface   MyInter{

}
public   interface   TestInter{

}
public   class   TestClass   implments   MyInter{ //实现一个接口

}
public   class   TestClass   implments   MyInter,TestInter{//实现多个接口

}

5.10 抽象类与接口的区别？
1.抽象类要被子类继承，接口要被类实现
2.接口只能做方法声明，抽象类中可以作方法声明，也可以做方法实现
3.接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量
4.接口是设计的结果，抽象类是重构的结果。
5.抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高
6.抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量
7.抽象类主要用来抽象类别，接口主要用来抽象功能。
5.11接口回调对象的含义和特征？
含义：
接口是不能new，通过实现了这个接口的子类去创建接口对象。
接口回调对象与上转型对象相似
上转型对象：子类的对象赋值给父类的变量
接口回调对象：将实现该接口的子类对象赋值给该接口变量。

接口回调对象的访问特征：
1、接口回调对象和实现该接口的子类对象还有接口名称，可以调用接口中的类变量
2、接口回调对象和实现该接口的子类对象，都不能调用接口的类方法，只能接口名称去调用接口中的类方法
3、接口回调对象和实现该接口的子类对象,可以调用接口中的抽象方法，只不过调用的是被子类重写以后的抽象方法
4、接口回调对象是不能调用子类自己定义的变量和方法,子类对象可以调用子类自己定义的变量和方法。

package com.click369.test4;
/**
 * interface是创建接口的关键
 * @author Administrator
 *
 */
public interface MyInterface {
	String  name="zhangsan";
	public static  void  testStatic(){
		System.out.println("MyInterface接口中的类方法");
	}
	void  test();
}

package com.click369.test4;
public class MyClass implements MyInterface{
	@Override
	public void test() {
		System.out.println("接口的子类重写接口中的抽象方法");
	}

	public  void  myClassMethod(){
		System.out.println("子类自己定义的方法");
	}
}

package com.click369.test4;

public class TestMain {
	public static void main(String[] args) {
		//接口是不能new
		//MyInterface  my=new MyInterface();
		//那么我们就要通过实现该接口的子类来创建接口对象
		//接口回调对象
		//实现该接口的子类对象赋值给接口变量--接口回调对象
		MyClass  mc=new  MyClass();
		//myinter---接口回调对象
		MyInterface myinter=mc;
		//1、接口回调对象和实现该接口的子类对象还有接口名称，可以调用接口中的类变量
		System.out.println(myinter.name);
		System.out.println(mc.name);
		System.out.println(MyInterface.name);
		//接口回调对象是不能调用接口中的类方法
		//myinter.testStatic();
		//实现接口的子类不能调用接口中的类方法
		//mc.testStatic();
		//可以使用接口名调用接口中的类方法
		//2.接口回调对象和实现该接口的子类对象，都不能调用接口的类方法，只能接口名称去调用接口中的类方法
		MyInterface.testStatic();
		//3.接口回调对象和实现该接口的子类对象,可以调用接口中的抽象方法，只不过调用的是被子类重写以后的抽象方法
		myinter.test();
		mc.test();
		//4.接口名称是不能调用接口中的抽象方法
		//MyInterface.test();
		
		//5.接口回调对象是不能调用子类自己定义的变量和方法,子类对象可以调用子类自己定义的变量和方法。
		//myinter.myClassMethod();
		mc.myClassMethod();
		
	}
}

在这里插入图片描述

5.12 static \ this \ super \ final 关键字？
static：
static–静态的【提前分配好内存空间】
1.使用static修饰的成员变量就是静态成员变量，或者类变量。
2.使用static修饰的方法就是静态方法，或者类方法。
3.使用static修饰的元素会在程序执行之前提前分配好内存空间。会在多个同类型对象之间共享，可以认为是多个同类型对象之间的交集存在。

package com.click369.test1;

public class TestClassDemo7 {
	public String  name; //实例变量
	public static String  testname; //类变量
}
package com.click369.test1;

public class TestMain {

	public static void main(String[] args) {
		/*
		//创建第一个TestClassDemo7类的对象
		TestClassDemo7  t1=new TestClassDemo7();
		//为第一个TestClassDemo7类的对象的name实例变量赋值zhangsan
		t1.name="zhangsan";
		//创建第二个TestClassDemo7类的对象
		TestClassDemo7  t2=new TestClassDemo7();
		//为第二个TestClassDemo7类的对象的name实例变量赋值lisi
		t2.name="lisi";
		//实例变量在同类型的对象中是独立存在的，t1对象的name值，不会因为t2对象为name赋值发生变化
		System.out.println("第一个TestClassDemo7类的对象的name值=="+t1.name);//zhangsan
		System.out.println("第二个TestClassDemo7类的对象的name值=="+t2.name);//lisi
		*/
		
		//创建第一个TestClassDemo7类的对象
		TestClassDemo7  t1=new TestClassDemo7();
		//为第一个TestClassDemo7类的对象的testname类变量赋值zhangsan
		t1.testname="zhangsan";
		//创建第二个TestClassDemo7类的对象
		TestClassDemo7  t2=new TestClassDemo7();
		//为第二个TestClassDemo7类的对象的testname类变量赋值lisi
		t2.testname="lisi";
		//类变量在同类型的对象中是共享的，
		System.out.println("第一个TestClassDemo7类的对象的testname值=="+t1.testname);//lisi
		System.out.println("第二个TestClassDemo7类的对象的testname值=="+t2.testname);//lisi
	}
}

final关键字：
1.final–最终的
2.可以修饰类，变量，方法
3.final修饰的java类，没有子类，不能被继承
final修饰的变量,不能被重新赋值，就是一个常量。
final修饰的方法，不能被重写。
方法重写–子类中有方法与继承自父类的方法一样，就是子类重写了父类的方法。

package com.click369.test1;
public final class Person {

}
package com.click369.test1;
//用final修饰的类，不能被继承。【没有子类】
public class Student extends Person{

}
在java中String类就是用final修饰的，因此我们不能去继承String类。
public final class String
4.用final修饰的变量，不能被重新赋值。【变量就成了常量】
例如：
package com.click369.test1;
public class TestClass {
    public  static  final String val="hello";
	public static void main(String[] args) {
		//final	int  num1=100;
		//num1=200;
		//System.out.println("num1=="+num1);
		//val="world";
		System.out.println("val=="+val);
	}
}
5.用final修饰的方法，不能被重写【方法重写】。
package com.click369.test2;
public  class TestClass {
	public final String  getInfo(){
		return "";
	}
}

package com.click369.test2;
public class SonClass extends TestClass{
	public  String  getInfo(){
		return "hello";
	}
}

super关键字
this – 出现在哪一个类中表示当前这个类的对象。【调用本类中的变量和方法】
super出现在哪一个类就表示该类的父类对象【用来在子类调用父类中的变量和方法】
super的使用
super()—调用父类无参数构造方法
super(xxxx)-----调用父类有参数构造方法

public  Student(){
	//调用父类有参数构造方法
		super("zhangsan");
		System.out.println("Student子类的无参数的构造方法");
	}
super.变量名称----调用被子类隐藏的成员变量值
例如：
public  void test1(){
		//可以通过super.成员变量名称，强制调用，被隐藏的成员变量值。
		System.out.println("name=="+super.name); //zhangsan
	}
super.方法名称([xxxxxx])-----调用被子类继承来的父类的方法
例如：
public  void testMethod(){
		//强制调用继承自父类的方法
		super.testMethod();
	}

this关键字
this–这个

public  class  Test{
public Test(){}

public  void  testMethod1(){}

public  void  testMethod2(){
//java程序=对象+消息【testMethod1()】
//new Test()  --- Test类的对象
new Test().testMethod1();
//由于在同一个类中使用的对象都是相同的，所以就通过一个this关键字去代替出现在同一个类中new  Test()
//this等价于 new Test()
//this就是 Test类的对象
this.testMethod1();
//在同一个类中调用本类的实例变量/实例方法，默认是this.实例变量/实例方法。可以省略this
testMethod1();
}

}

this出现在哪一个类中就表示哪一个类的对象
this=====>new 本类构造方法
this=本类对象
静态方法中绝对不能有this
this可以调用被隐藏的成员变量值

'小手冰凉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
5.继承、抽象类、接口

继承、抽象类、接口5.1什么是继承？如何完成一个继承关系？继承1.面向对象的特征之一。[封装，继承，多态]2.继承是一种通过现有的类，创建出新类的机制。3.继承实际上一种类与类之间关系。继承是一种通过现有的类，创建出新类的机制。父类—现有的类【已经存在的】。子类—创建出来的新类。子类可以得到父类中的部分变量和方法。如何完成一个继承关系：通过extends关键字实现继承关系格式：访问限制修饰符 class 子类的类名 extends 父类的类名{}//现有的类p
复制链接

扫一扫