java中的抽象类和接口

最新推荐文章于 2022-05-17 15:25:55 发布

胡椒粉02

最新推荐文章于 2022-05-17 15:25:55 发布

阅读量280

点赞数

分类专栏： java学习开始文章标签： java

本文链接：https://blog.csdn.net/qq_42311690/article/details/107980866

版权

java学习开始专栏收录该内容

75 篇文章 2 订阅

订阅专栏

5.12.什么是上转型对象及其基本特征？
上转型对象—子类对象赋值给父类变量。
例如：

package chou20200813_1_1;
//父类
public class Perosn {
	public void tP() {
    System.out.println("父类Person的实例方法");	
	}
}

package chou20200813_1_1;
//子类
    public class Student extends Perosn{
	public void tS() {
    System.out.println("子类Student的实例方法");		
	}

package chou20200813_1_1;
public class Test1 {
	public static void main(String[] args) {
	//上转对象---子类对象赋值给父类对象。
    //person上转型对象表示将子类对象向上转型成父类对象
	Perosn person=new Student();//person上转型对象
	//上转型对象可以调用被子类继承的变量和方法，不用调用子类自己创建的变量和方法。
	person.tP();
	//perosn.ts();
   //上转型对象不能调用子类自己创建的变量和方法，那么如果一定要强制使用子类自己创建的变量和方法，
   //此时我们需要将上转型对象强制类型转换成子类对象。
	Student stu=(Student)person;
	stu.tS();
    }
}

运行结果：

上转型对象的可以调用被子类继承的变量和方法，不能调用子类自己创建的变量和方法。
上转型对象不能调用子类自己创建的变量和方法，那么如果一定要强制使用子类自己创建的变量和方法，此时我们需要将上转型对象强制类型转换成子类对象。
5.13.什么是抽象类？
类–用来描述具有共同性质的一组事物的自定义复合数据类型
通过class关键字创建一个java类。
通过abstract 修饰的java类就是抽象类。
格式: 访问修饰符 abstract class 类名{}
例如：
public abstract class Hello{ }
5.14.为什么要使用抽象类？
  抽象类的出现体现出java的重构.[重复的动作提取出来]
  抽象类是提供可以由子类共享的一般形式，由子类根据自己的实际情况去处理这个一般形式。
  例如:坐车收费，出租车有收费功能【1元/公里】，公交车有收费功能【全程1元】
  抽象类的子类往往都是同一种事物。
5.15.抽象类中可以有哪些元素？
  抽象类中的元素实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。
  抽象方法–abstract修饰，没有方法体的方法。
  抽象方法就是抽象类提供给子类的一般形式。
  抽象类中可以有抽象方法，也可以一个抽象方法都没有。普通的java类中是不能有抽象方法的。
例如:

package chou20200813_1_1;
public abstract class Abstract{
	public int id=6666;//实例变量
	public static String name="liuyi";//类变量
	public Abstract() {
		System.out.print("构造方法");
	}
	public void tM() {
		System.out.println("实例方法");		
	}
	public static void sM() {
		System.out.println("类方法");
		
	}
     //abstract修饰，没有方法体的方法就是抽象方法
	 //抽象方法就是抽象类提供给子类的一般形式
	 //抽象类中可以有抽象方法，也可以一个抽象方法都没有
	public abstract void aM();
	
}

5.16.抽象类的具体用法
  1.抽象类不能new
  2.普通的java类继承了抽象类，就需要重写抽象类中的抽象方法，否则将这个普通的java类改成抽象类。
  3.抽象类可以继承其他的抽象类，可以不用重写抽象方法。
  4.利用上转型对象创建出抽象类对象
  5.抽象类对象可以访问抽象类中的实例变量、类变量、构造方法、实例方法、类方法、【抽象方法】。
  6.抽象类对象访问抽象方法时候实际上访问的是子类重写以后的抽象方法。
  7.当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象。

package chou20200813_2_1;
	public abstract class Abstract{
		public int id=6666;//实例变量
		public static String name="liuyi";//类变量
		public Abstract() {
			System.out.print("构造方法");
		}
		public void tM() {
			System.out.println("实例方法");		
		}
		public static void sM() {
			System.out.println("类方法");
			
		}
	     //abstract修饰，没有方法体的方法就是抽象方法
		 //抽象方法就是抽象类提供给子类的一般形式
		 //抽象类中可以有抽象方法，也可以一个抽象方法都没有
		  public abstract void aM();	
	}

package chou20200813_2_1;
public class Myclass {
       public  void tM(Abstract mac) {

}
}

package chou20200813_2_1;

public class SunClass extends Abstract {
	//子类重写抽象类的抽象方法
	//去掉abstract,加上方法体
	public void aM() {
	System.out.println("子类重写抽象类的抽象方法");
	}
}

package chou20200813_2_1;
    public class Test1 {
	    public static void main(String[] args) {
		//抽象类的具体用法
		//1.抽象类不能new
		//Abstract mac=new Abstract();
		//2.利用上转型对象创建出抽象类对象
		  Abstract mac=new SunClass();
		  System.out.println("id=="+mac.id);
		  System.out.println("name=="+Abstract.name);
		  System.out.println("name=="+mac.name);
		  mac.tM();
		  mac.sM();
		  //子类重写以后的抽象方法
		  mac.aM();
		  Myclass mc=new Myclass();
		  //当某一个普通的java类中的方法参数是抽象类类型的时候，可以传递上转型对象，也可以是抽象类的子类对象
		  mc.tM(mac);
		  //抽象类的子类对象
		  SunClass sun=new SunClass();
		  mc.tM(sun);		  
	}
}

运行结果为:

5.17.什么是接口？
通过interface关键字修饰的java元素就是接口。
package com.wangxing.test1;
//接口
public interface MyInterface {
}
5.18.为什么要使用接口？
  接口的出现体现出java的扩展.[为了以后程序扩展方便]
  接口是提供可以由子类共享的一般形式，由子类根据自己的实际情况去处理这个一般形式。
  例如:收费，出租车有收费功能【1元/公里】，飞机有收费功能【全程1000元】
  接口的子类往往都是不同种类事物。
  接口主要是提供功能，提供功能不去实现该功能，由不同的不同种类事物去实现。
  为了克服java的单继承问题，可以使用接口，可以被使用多个。
5.19.接口中可以有哪些元素？
  接口中可以有类变量、类方法、抽象方法。
  1.接口中变量一定是 public static修饰的类变量。
  2.接口中的类方法一定是public修饰的，public可以被省略
  3.接口中的抽象方法一定是public abstract修饰的，public abstract可以省略
例如：

package chou20200813_3_1;
//接口
public interface MyInterface {
	//接口中的变量一定是public static修饰的类变量
	//public static是可以省略
	public int id=10086;//类变量
	int age=23;
	public static String name="zhangsan";//类变量
	//接口中没有构造方法
	//public MyInterface(){}
	//接口中没有实例方法
	//public void testMethod(){}
	//接口中的类方法一定是public 修饰的,public可以被省略
	public static void staticMethod() {
		System.out.println("接口中的类方法");
	}
	//接口中的抽象方法一定是public abstract修饰的
	//public abstract可以省略
	public abstract void abstractMethod1();
	abstract void abstractMethod2();
	void abstractMethod3();		
	}

5.20.接口的具体用法
  1.接口不能new
  2.类可以通过implements关键字去实现一个/多个接口
  实现一个public class MyClass implements MyInterface{}
  实现多个接口 public class MyClass implements MyInterface1,MyInterface2,…,MyInterface_n{}
  3.普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类.
  4.抽象类去实现一个/多个接口，不需要重写接口中的抽象方法。
  5.接口可以继承接口，并且可以继承父接口中的所有元素.
package com.wangxing.test1;
  //接口可以继承接口，并且可以继承父接口中的所有元素
  public interface DemoInterface extends MyInterface{
  }
  6.利用接口回调对象创建出接口对象
  7.当某一个普通的java类中的方法参数是接口类型的时候，可以传递接口回调对象，也可以是接口的子类对象。
例如:

package chou20200813_3_1;
//接口
public interface MyInterface {
	//接口中的变量一定是public static修饰的类变量
	//public static是可以省略
	public int id=10086;//类变量
	int age=23;
	public static String name="zhangsan";//类变量
	//接口中没有构造方法
	//public MyInterface(){}
	//接口中没有实例方法
	//public void testMethod(){}
	//接口中的类方法一定是public 修饰的,public可以被省略
	public static void staticMethod() {
		System.out.println("接口中的类方法");
	}
	//接口中的抽象方法一定是public abstract修饰的
	//public abstract可以省略
	public abstract void abstractMethod1();
	abstract void abstractMethod2();
	void abstractMethod3();		
	}

package chou20200813_3_1;
//类可以通过implements关键字去实现一个/多个接口
//普通的类去实现一个/多个接口，就需要将每一个接口中的抽象方法重写，否则就需要将这个普通的类改成抽象类
public class MyClass implements MyInterface {
	public void abstractMethod1() {
		System.out.println("子类重写抽象类的抽象方法");
	}

    public void abstractMethod2() {
    	
    }
    public void abstractMethod3() {
    }
    }

package chou20200813_3_1;

public class DoClass {
	 public  void  test(MyInterface inter) {
      }
}

运行结果

5.21.抽象类与接口的区别

5.22.什么是接口回调对象及其基本特征？
接口回调对象与上转型对象很相似
上转型对象–子类对象赋值给父类变量。
接口回调对象—实现了该接口的子类对象赋值给接口变量。
接口回调对象可以调用被子类重写的抽象方法，但是不能调用子类自己的定义的变量和方法，如果一定要调用子类自己的定义的变量和方法，那么就需要将接口回调对象强制类型转换成子类对象
例如：

package chou20200813_4_1;

public class SunClass implements TestInterface{
	public void sunMethod() {
		System.out.println("SunClass类的实例方法");	
	}
	public void testMethod() {
		System.out.println("子类重写接口的抽象方法");
	}
}

package chou20200813_4_1;
   public interface TestInterface {
	void testMethod();

}

package chou20200813_4_1;
public class Test1 {
	public static void main(String[] args) {
	    //接口回调对象---实现了该接口的子类对象赋值给接口变量。
		TestInterface inter1=new SunClass();
		//接口回调对象可以调用被子类重写的抽象方法，但是不能调用子类自己的定义的变量和方法
		inter1.testMethod();
		//inter1.sunMethod();
		//如果一定要调用子类自己的定义的变量和方法，那么就需要将接口回调对象强制类型转换成子类对象
		SunClass sc=(SunClass)inter1;
		sc.sunMethod();		
	}
}

运算结果

5.23.static \ this \ super \ final 关键字的用法
static–静态的【提前分配内存】
   修饰的变量就是静态成员变量【类变量】，可以用类名访问，也可以用对象访问
  修饰的方法就是静态方法量【类方法】，可以用类名访问，也可以用对象访问
this—本类对象【出现在哪一个类中就表示哪一个类的对象】
  本类中调用本类的实例变量\类变量\实例方法\类方法，可以省略
   this是不能出现在静态方法中
super–子类中表示父类对象
   子类中访问父类构造方法“super([参数])”。
  子类中访问父类的实例方法/实例变量”super.实例变量/实例方法”。
final—最终的
  final修饰的变量不能被重新赋值。
  fianl修饰的静态成员变量叫静态常量。【静态常量全字母大写】
  例如: public final static String TEXT=“java”;
  final修饰的方法不能被重写。
  final修饰的类不能被继承，没有子类。
例如:

package chou20200813_5_1;
//final修饰的类不能被继承，没有子类
//public final class TestClass{
public class TestClass {
	public final String name="zhangsan";
	//final修饰的静态成员变量叫静态常量。【静态常量全字母大写】
	public final static String TEXT="java";
	public final void info() {
	System.out.println("父类TestClass类的实例方法");
	}
}

package chou20200813_5_1;
public class MyClass extends TestClass{
	
	//final修饰的方法不能被重写
	/*
	public  void info() {
		System.out.println("子类重写父类的方法");
	}
	*/
}

package chou20200813_5_1;
public class Test1 {
	    public static void main(String[] args) {
		TestClass tc=new TestClass();
		System.out.println("name=="+tc.name);
		//final修饰的变量不能被重新赋值
		//tc.name="lisi";
		System.out.println("name=="+tc.name);
		tc.info();
		MyClass  mc=new MyClass();
		mc.info();
	}
}

运行结果

胡椒粉02

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java中的抽象类和接口

5.12.什么是上转型对象及其基本特征？上转型对象—子类对象赋值给父类变量。例如：package chou20200813_1_1;//父类public class Perosn { public void tP() { System.out.println("父类Person的实例方法"); }}package chou20200813_1_1;//子类 public class Student extends Perosn{ public void tS()
复制链接

扫一扫