java抽象类和接口

最新推荐文章于 2024-06-27 15:05:51 发布

司天宏

最新推荐文章于 2024-06-27 15:05:51 发布

阅读量203

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/qq_41532872/article/details/85038366

版权

java初级专栏收录该内容

78 篇文章 6 订阅

订阅专栏

1.抽象类

在这里插入图片描述


public abstract  class People {

	private String name;
	private int age;
	private String sex;
	private final int a = 20;
	
	public abstract void eat();
	
	public abstract void work();
	
	public abstract void a();
	
	public abstract void b();
	
	public abstract void c();
	
	public abstract void d();
	
	public abstract void e();
	
	public abstract void f();
	
	public abstract void g();
	
	public void sleep(){
		System.out.println("睡觉");
	}
	
	
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public People(String name, int age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public People() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	

}

public abstract  class Student extends People {
	
	public Student() {
		//super();
		
	}

	public static void main(String[] args) {
		//People p1 = new Student();
	
	}

	@Override
	public void eat() {
		System.out.println("学生吃肉");
	}

	@Override
	public void work() {
		System.out.println("学习");
	}

	
	
	
}

public abstract class Teacher extends People {

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void work() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void a() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void b() {
		// TODO Auto-generated method stub
		
	}

	
	
}


public abstract class Doctor extends People {

	@Override
	public void eat() {
		// TODO Auto-generated method stub

	}

	@Override
	public void work() {
		// TODO Auto-generated method stub

	}

	@Override
	public void a() {
		// TODO Auto-generated method stub

	}

	@Override
	public void b() {
		// TODO Auto-generated method stub

	}

	@Override
	public void c() {
		// TODO Auto-generated method stub

	}

	@Override
	public void d() {
		// TODO Auto-generated method stub

	}

	@Override
	public void e() {
		// TODO Auto-generated method stub

	}

	@Override
	public void f() {
		// TODO Auto-generated method stub

	}

	@Override
	public void g() {
		// TODO Auto-generated method stub

	}

}

public class Test {
	
	/*
	 * 抽象类的学习
	 * 
	 * 抽象类:把子类中那些具有共同属性以及共同行为的特性，归纳，总结出一个父类，我们把这个父类，称为抽象类
	 * 虽然我们口头上称这种类为抽象类，但是java语法结构上并没有体现出这种抽象的概念
	 * 那么怎么让一个类变为抽象类？
	 * 
	 * 1：给类加关键字：abstract
	 *    语法格式
	 *    public abstract class 类名{
	 *    
	 *    }
	 * 2:如果一个类中有抽象方法，那么这个类一定是抽象类
	 *   抽象方法 语法格式:抽象方法只有方法声明，没有方法体。
	 *    修饰符  abstract 返回值  方法名();
	 *    
	 * 3:如果一个类继承了抽象类
	 *     那么这个类 
	 *     1：要么重写父类中所有抽象方法   
	 *     2：要么自己变成抽象类
	 *     
	 *  抽象类的作用？
	 *   1:减少了抽象类中方法体的写法，提高了部分效率
	 *   2:规定了一个类必须做什么，约束了子类的行为，大大的增强了类的范围性，使得一个类在设计的时候，不是那么的随意
	 *     但是正因为类的规范性，使得类与类之间的耦合关系大大增加，无形之中给子类增加了负担
	 *     
	 *  抽象类的细节处理
	 *   1：抽象类是否有变量:有
	 *   2：抽象类是否有常量:有
	 *   3：抽象类是否有抽象方法
	 *        3.1 抽象类中可以没有抽象方法，也可以有
	 *        3.2 有抽象方法的类,必须是抽象类
	 *   4:抽象类是否有成员方法:有
	 *   5:抽象类是否有构造方法:有
	 *   6:抽象类是否可以创建对象:不可以创建对象
	 *   7:每个类至少会提供一个构造方法
	 *      7.1:向上引用，调用父类的构造方法    
	 *      7.2:初始化属性值
	 *   8:抽象类就是为了被继承的，如果没有子类继承，抽象类没有任何作用
	 *   9:所以多态的特性，在抽象类最能体现出来，因为多态的前提是继承
	 *     
	 *     
	 * 
	 */
	public static void main(String[] args) {
		
		//People p = new People();
		//People p = new Student();  //多态  向上转型
		
	}

}

2.接口

在这里插入图片描述


public abstract class People {
	
	private String name;
	private int age;
	private String sex;
	
	public abstract void eat();
	
	public void sleep(){
		System.out.println("躺着睡");
	}
	
	public abstract void work();
	
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public People(String name, int age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public People() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	

}


public class Student extends People {

	@Override
	public void eat() {
		System.out.println("学生吃肉");
	}

	@Override
	public void work() {
		System.out.println("学JAVA");
	}
	
	public void playGame(){
		System.out.println("LOL");
	}
	
	

}


public class Teacher extends People {

	@Override
	public void eat() {
		System.out.println("老师吃菜");
	}

	@Override
	public void work() {
		System.out.println("教JAVA");
	}
	
	public void running(){
		System.out.println("跑步");
	}

}


public interface SmokeInter {
	
	
	//抽烟行为
	void smoking();

}

public class SmokeStudent extends Student implements SmokeInter{

	@Override
	public void smoking() {
	   System.out.println("学生抽烟");
	}

}

public class SmokeTeacher extends Teacher implements SmokeInter {

	@Override
	public void smoking() {
	  System.out.println("老师抽烟");
	}

}

public class Test {
	
	/*
	 * 父类：People
	 *    1个实现的方法：sleep()
	 *    2个抽象的方法：eat()  work()
	 * 子类1：Student
	 *    继承父类的方法：sleep()
	 *    重写父类的方法：eat()  work()
	 *    自己的方法：playGame()
	 * 子类2：Teacher
	 *    继承父类的方法：sleep()
	 *    重写父类的方法：eat()  work()
	 *    自己的方法：running() 
	 * 接口：SmokeInter  抽烟接口
	 * 
	 *  实现类1：SmokeStudent  extends Student implements SmokeInter
	 *  
	 *  实现类2：SmokeTeacher  extends Teacher implements SmokeInter
	 *          
	 *    
	 *  新的需求：需要加一个抽烟的方法，问题是这个方法应该定义在哪个类中？
	 *  问题1：抽烟是一个行为，它并不属于任何一个类
	 *  解决方法：把抽烟这个行为，定义在抽烟的接口中
	 * 
	 *  接口：USB接口，可以连接电脑和键盘，接口起到了一个桥梁作用
	 *    类：电脑类和键盘类
	 *    如何让电脑和键盘产生联系
	 *    1：继承方案
	 *      继承会是两个2类产生耦合关系
	 *    2：接口方案
	 *       电脑通过一个接口把键盘联系起来，用的时候插上，不用的时候拔掉，起到一个即插即用的功能
	 *     接口是类与类之间一个桥梁，起到了一个联通的作用，既不产生耦合关系，而且功能越来越强大
	 *     一个类可以连接多个接口，突破了一个类原本的类型限制，使得整个类的功能很丰富    
	 *     
	 *   接口的语法格式:
	 *   interface
	 *   
	 *   修饰符 interface 接口名(){
	 *     ...
	 *   }
	 *   
	 *   如何让一个类实现接口
	 *     修饰符  class 类名 implements 接口名{
	 *    
	 *     }
	 *     
	 *   全栈工程师 
	 */
	public static void main(String[] args) {
		
		//创建一个抽烟的学生对象
		People stu1 = new SmokeStudent();
		People p = new SmokeTeacher();
		People p1 = new Student();
		People p2 = new Teacher();
	
		//优点:可以接受不同类型的对象
		//缺点:多态不能调用子类独有的方法
		System.out.println("---普通人类---");
		stu1.eat();
		stu1.sleep();
		stu1.work();

		Student stu2 = new SmokeStudent();
		
		System.out.println("---普通学生---");
		stu2.eat();
		stu2.sleep();
		stu2.work();
		stu2.playGame();
		
		SmokeStudent stu3 = new SmokeStudent();
		//优点：既能调用继承父类的方法，也能调用自己独有的方法，功能强大
		//缺点：类型单一，如果把真个类型作为方法的形参的话，功能单一
		
		System.out.println("-----抽烟的学生-------");
		stu3.eat();
		stu3.sleep();
		stu3.work();
		stu3.playGame();
		stu3.smoking();
		
	}

}


```
public class Test {
	
	/*
	 * 接口和实现类起名规则
	 * 
	 * 例如： 接口名称：StudentDao，StudentService
	 *       实现类：StudentDaoImpl，StudentServiceImpl
	 * 
	 */

}

```

```

public interface TestInter {
	/*
	 * 接口的内部结构
	 * 
	 * 1：接口是否有变量:没有
	 * 2：接口是否有常量:有
	 *    默认修饰符  public static final
	 * 3：接口是否有实现方法:没有 
	 *   注意 jdk1.8之前没有
	 *   1.8之后有了，静态实现方法，默认方法
	 * 4：接口是否有抽象方法：有
	 *   默认修饰符  public abstract 返回值  方法名();
	 * 5：接口是否有构造方法:没有
	 *   接口不是类，所以也就没有必要写构造器
	 *   
	 *   抽象类是为了被继承的
	 *   接口是为了被实现的
	 */
	
	  int a = 10;
	
	final int b = 20;
	
	
	/*
	default void ss(){
		
	}
	*/
	 void s();
	
}	



                3.抽象类与接口


public interface A extends D,E {

}

public abstract class B extends C implements A,D{

}

public class C{

}
public interface D {
	
	public void show();
	public void main(String[] args) ;

}

public interface E {

	//public abstract void show();
}

```

```
public class Test {
	
	/*
	 * 接口的用法
	 * A:接口
	 * B实现类，C实现类
	 * 
	 * A a = new B();
	 * 等号左边是接口类型，右边是实现类的对象 
	 * 多态的重要体现形式：向上转型
	 * 
	 * 实际开发中，方法的形参是接口类型，实际上需要我们传入一个实现类对象
	 * 实际开发中，方法的形参是抽象类，实际上需要我们传入一个子类对象
	 * 
	 * 面向接口编程：有利于大型项目的的可扩展和可维护性
	 * 
	 * 类与类的关系
	 *   继承，单继承，但是有继承链
	 * 类与接口的关系
	 *   实现关系，多实现
	 * 接口和接口的关系
	 *   继承关系，多继承
	 * java的的最基本的2大组织结构：类与接口  
	 * 接口把方法定义好，等着实现类来实现
	 * 实际开发，先定义接口，在写具体的实现类
	 * 注意：一个类既能继承父类，还能实现接口，但是必须先继承，后实现
	 *   
	 * 
	 * 面试题：接口和抽象类的区别？
	 * 1：方法实现
	 *   抽象类可以有实现方法
	 *   接口没有，1.8之后有了,可以有静态方法，默认方法
	 * 2：实现方式
	 *    抽象类是extends继承的
	 *    接口是implements实现的
	 * 3 构造器 
	 * 	    抽象类可以有构造器 
	 *   接口不能有构造器
	 * 4：方法修饰符
	 *   抽象类的抽象方法可以有public、protected和default这些修饰符 
	 *   接口方法默认修饰符是public。你不可以使用其它修饰符。      
	 * 5:继承
	 *   抽象类的抽象方法可以继承一个类和实现多个接口
	 *   接口可以继承一个或多个其它接口
	 *   
	 * 什么时候使用抽象类和接口？
	 *    具体类  is..a 抽象类   是什么   类的说法
	 *    抽烟的学生是学生
	 *    狗是一个动物
	 *    
	 *    ..like..a.. 像什么
	 *    如果你的类的功能，是由很多不同之间的功能组合而成，那么应该使用接口多实现的方式
	 *    
	 *   
	 *    定义一个抽象类 Animal  3个方法 吃饭  睡觉 工作
	 *    2个子类：Dog，Cat
	 *    定义2个接口  狗要钻火圈，猫要算算数
	 *    定义2个子类  钻火圈的狗，算算术的猫
	 *    
	 * 
	 */
	
	
	public void show(A a){
		
	}
	
	public static void main(String[] args) {
		//A a = new A();
		//A a = new B();
		//A a1 = new C(); //面向接口编程
		
		//B b1 = new B(); //面向对象编程
		//Test t = new Test();
		//t.show(a);
		//t.show(a1);
		
		//System.out.println(a);
		
	}

    }

司天宏

关注

1
点赞
踩
0

收藏

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

1.抽象类public abstract class People { private String name; private int age; private String sex; private final int a = 20; public abstract void eat(); public abstract void work(); publi...
复制链接

扫一扫