Java学习笔记13抽象类和接口_20200511

最新推荐文章于 2023-03-28 18:42:54 发布
最新推荐文章于 2023-03-28 18:42:54 发布
阅读量186 收藏 2
点赞数
分类专栏： Java基础学习笔记2020
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gotojoko/article/details/106051495
版权
这篇博客主要介绍了Java中的抽象类和接口的概念及其使用。首先回顾了上一章的作业，涉及Person和Student类的设计。接着详细讲解了抽象类的应用场景，包括抽象类的声明和使用规则。然后介绍了接口，强调接口作为纯粹抽象类的角色，以及接口的继承。此外，还探讨了内部类的不同类型，如局部内部类、静态内部类和匿名内部类。最后，通过Frock、Shirt和Coat类的例子展示了如何使用抽象类和接口进行设计。
摘要由CSDN通过智能技术生成

这里写自定义目录标题

第13章 抽象和类

01 作业回顾

***练习

  1. 编写一个Person类，包括属(name,age),构造器，方法say(返回自我介绍的字符串)。
    编写一个student类，继承Person类，增加id,score属性，以衣构造器，并覆盖say方法。

编写Test类，创建Peron和Student对象，调用say方法输出自我介绍。

package day11;

class Person{
	protected String name;
	protected int age;
		
	public Person() {
		super();
	}

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	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 void say(){
		System.out.println("name:" + name);
		System.out.println("age:" + age);
	}	
}

class Student extends Person{
	private int id;
	private int score;
	public Student(String name,int age,int id, int score) {
		super(name,age);
		this.id = id;
		this.score = score;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}

	public void say() {
		super.say();
		System.out.println("id:" + id);
		System.out.println("score: " + score);
	}	
}


public class Day113 {
	public static void main(String[] args) {
		Person p = new Person("张三",20);
		p.say();
		
		Student s  = new Student("李四", 10, 1, 99);
		s.say();		
	}

}



/*
name:张三
age:20
name:李四
age:10
id:1
score: 99
*/

在这里插入图片描述
在这里插入图片描述

02 抽象类

2.1 示例

在这里插入图片描述
2.1.1 初步设计

package day11;

class GraphicObject {
	protected int x;
	protected int y;
	protected String color;
	
	public GraphicObject(int x, int y, String color) {
		super();
		this.x = x;
		this.y = y;
		this.color = color;
	}
	
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public void moveTo(int x,int y) {
		this.x = x;
		this.y = y;
		
	}
	public void showLocation(){
		System.out.println("x = " + x + ", y = " + y);
	}
		
	//不知道如何实现
	public void draw() {
		
	}
	
	class Circle extends GraphicObject {
		public Circle(int x, int y, String color) {
			super(x,y, color);			
		}
		public void draw() {
			System.out.println("draw a circle at[" + x + "," + y + "]");
		}
	}
	
	class Rectangle extends GraphicObject {
		public Rectangle(int x, int y, String color) {
			super(x, y, color);
		}
		
		public void draw() {
			System.out.println("draw a Rectangle at ["  + x + "," + y + "]");			
		}
	}	
}

public class Day115 {
	public static void main(String[] args) {
		Circle c = new Circle(1, 1, "红色");
		c.draw();
		
		Rectangle r = new Rectangle(2, 2, "蓝色");
		r.draw();
	}
}



/*
draw a circle at[1,1]
draw a Rectangle at[2,2]
*/

在这里插入图片描述
在这里插入图片描述
图形对象都具有某些状态（位置，线条颜色）和 行为（moveTo,draw）。
对于所有的图形，这些状态和行为中的一些是相同（位置，线条颜色，moveTo）。

draw有些特殊。每个子类的draw方法提供的功能不同。
可以在父类中提供一个draw方法，在子类中使用方法重写来完成特定的draw方法。

GraphicObject（图形）应该是抽象的，不应该有具体的对象。在这里插入图片描述

对于这种情况可以使用抽象类来实现。

2.1.2 加入抽象类思想，进行优化改进

package day11;

//有抽角方法的类必须声明为抽象类
abstract class GraphicObject {
	protected int x;
	protected int y;
	protected String color;
	
	public GraphicObject(int x, int y, String color) {
		super();
		this.x = x;
		this.y = y;
		this.color = color;
	}
	
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public void moveTo(int x,int y) {
		this.x = x;
		this.y = y;
		
	}
	public void showLocation(){
		System.out.println("x = " + x + ", y = " + y);
	}
		
	//声明为抽象的方法，因为不知道如何云实现它
	public abstract void draw(); 
	
}		
		
	 class Circle extends GraphicObject {
		public Circle(int x, int y, String color) {
			super(x,y, color);			
		}
		
		//子类必须实现父类的抽象方法，否则这个子类必须声明为抽象类
		public void draw() {
			System.out.println("draw a circle at[" + x + "," + y + "]");
		}
	}
	
	class Rectangle extends GraphicObject {
		public Rectangle(int x, int y, String color) {
			super(x, y, color);
		}		
		public void draw() {
			System.out.println("draw a Rectangle at ["  + x + "," + y + "]");			
		}
	}	


public class Day115 {
	public static void main(String[] args) {
		//编译错误，抽象类不能被实例化
//		GraphicObject g = new GraphicObject(0, 0, "黑色");
		
		Circle c = new Circle(1, 1, "红色");
		c.draw();
		
		Rectangle r = new Rectangle(2, 2, "蓝色");
		r.draw();
	}
}

在这里插入图片描述

在这里插入图片描述
2.1.3

子类必须实现父类的抽象方法，否则这个子类必须声明为抽象类
在这里插入图片描述

2.2

抽象类使用abstract关键字来声明，它可以包含抽象方法，也可以不包含抽象方法。

声明为抽象类，又不包含抽象方法，仅仅是为了避免被实例化。

抽象类不能被实例化，但是可以被继承。

如果一个类包含了抽象方法，那么它必须声明为一个抽象类。

如果一个类继承了抽象类，它通常要实现抽象类的抽象方法，如果没有，那么这个子类也必须被声明为抽象的。

抽象类天生就是用来被继承的。抽象类实现了它所有子类必须使用的通用方法。这样子类就可以直接调用。
抽象方法则留给子类根据自己的情况做不同的实现。

定义抽象方法的意义在于：给所有的子类制定一种规则，子类必须要实现抽象方法。

抽象类使用abstract关键字来声明，它可以包含抽象方法，也可以不包含抽象方法。在这里插入图片描述

03 接口

接口定义了一个类所能对外提供的功能。接口不能被实例化，只能被实现。

接口可以理解为纯粹的抽象类，接口中的所有方法都是抽象的。

接口描述了一种规则。

3.1 示例

3.1.1

package day11;

//使用关键字interface声明了一个接口
//接口描述了一种功能
interface Flyable{
	
//	public abstract void fly();
	//public abstract不是必须的，接口的方法默认就是public abstract
	void fly();	
}

//使用关键字implements来实现一个接口
class Aeroplane implements Flyable{
	//实现一个接口，必须实现接口中的所有方法，否则这个类必须声明为抽象类
	@Override
	public void fly() {
		System.out.println("飞机能飞");
	}	
}

class Bird implements Flyable {

	@Override
	public void fly() {
		System.out.println("鸟能飞");
	}	
}


public class Day117 {
	public static void main(String[] args) {
		Bird bird = new Bird();
		bird.fly();
		Aeroplane aeroplane = new Aeroplane();
		aeroplane.fly();
	}
}

在这里插入图片描述
3.1.2 使用接口类型的变量

package day11;

//使用关键字interface声明了一个接口
//接口描述了一种功能
interface Flyable{
	
//	public abstract void fly();
	//public abstract不是必须的，接口的方法默认就是public abstract
	void fly();

}

//使用关键字implements来实现一个接口
class Aeroplane implements Flyable {
	// 实现一个接口，必须实现接口中的所有方法，否则这个类必须声明为抽象类
	@Override
	public void fly() {
		System.out.println("飞机能飞");
	}
}

class Bird implements Flyable {
	@Override
	public void fly() {
		System.out.println("鸟能飞");
	}	
}

public class Day117 {
	public static void main(String[] args) {
		Bird bird = new Bird();
		bird.fly();
		Aeroplane aeroplane = new Aeroplane();
		aeroplane.fly();
		
		//使用接口类型的变量
		//Aeroplane实现了Flyable接口，因此这个对象可以被Flyable类型的变量引用
		Flyable f1 = new Aeroplane();
		f1.fly();//多态，会调用其实际引用对象的fly方法
		//Bird实现了Flyable接口，因此这个对象可以被Flyable类型的变量引用
		Flyable f2 = new Bird();
		f2.fly();//多态，会调用其实际引用对象的fly方法		
	}
}

在这里插入图片描述
3.1.3

接口中的变量总是public static final的，接口中的变量不能声明为private。

//接口中的变量总是public static final的，接口中的变量不能声明为private。
package day11;

interface ExampleInterface1 {
	//接口中的變量默认是public static final
	//一般常量用大写
	int VALUE1 = 10;
	public int VALUE2 = 20;
	public static int VALUE3 = 30;
	public static final int VALUE4 = 40;
	//接口中不允许private变量
//	private int value5 = 50;//编译错误	
}

public class Day118 {
	public static void main(String[] args) {
		System.out.println(ExampleInterface1.VALUE1);		
	}
}

在这里插入图片描述

3.2 接口的继承

package day11;

interface Interface1 {
	void method1();
}

//Interface2继承了Interface1中的所有方法声明
interface SubInterface1 extends Interface1 {
	void  method2();
}

//ctrl + 1 自动修复错误
//实现Interface1接口，必须要实现method1和method2两个方法
class Class1 implements SubInterface1 {

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

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

public class Day119 {
	public static void main(String[] args) {
		
	}
}

在这里插入图片描述

一个类可以实现多个接口，它必须要实现接口中的所有方法。

package day11;

interface Singer {
	void song();	
}

interface Dancer {
	void dance();
}

//一个类可以实现多个接口，它必须要实现接口中的所有方法
//可以不实现接口中的所朋方法，但是必段志明为抽象类。
class Actor implements Singer,Dancer {

	@Override
	public void dance() {
		System.out.println("dance");
	}

	@Override
	public void song() {
		System.out.println("song");
	}
	
}

public class Day120 {
	public static void main(String[] args) {
		Singer s1 = new Actor();
		s1.song();//多态，调用实际引用对象的方法
//		s1.dance();  //编译错误，变量的类型是Singer ,所以只能看到Singer中的方法
		
		//强制类型转换
		Dancer s2=(Dancer)s1;
		s2.dance();
//		s2.song(); //编译错误，变量的类型是Singer ,所以只能看到Singer中的方法
		
	}
}

在这里插入图片描述

04 内部类

4.1 可以将一个类的定义放到另外一个类的内部，这叫做内部类。

//Foo是一个外部类
class Foo {
	//Bar是一个内部类
	class Bar {
		
	}
}

4.2 例

//Foo是一个外部类
class Foo {
	private int v1;
	
	public Foo(int v1) {
		super();
		this.v1 = v1;
	}
	
	public void fooF() {
		Bar bar = new Bar();
		bar.barF();
	}

	//Bar是一个内部类
	class Bar {
		public void barF(){
			//内部类可以直接访问外部类的数据
			//内部类的对象有一个外部类对象的引用outer,无视访问修饰符
			//outer不是java的关键字
			System.out.println(v1);
		}
	}
}

public class Day121 {
	public static void main(String[] args) {
		//创建了一个外部类的对象
		Foo f = new Foo(10);
		f.fooF();
	}
}

在这里插入图片描述

4.3 局部内部类

例一

//Foo是一个外部类
class Foo {
	private int v1;
	
	public Foo(int v1) {
		super();
		this.v1 = v1;
	}
	
	public void fooF() {
		//Bar是一个局部内部类
		class Bar {
			public void barF(){
				//内部类可以直接访问外部类的数据
				//内部类的对象有一个外部类对象的引用outer,无视访问修饰符
				//outer不是java的关键字
				System.out.println(v1);
			}
		}
		
		Bar bar = new Bar();
		bar.barF();
	}
}

public class Day121 {
	public static void main(String[] args) {
		//创建了一个外部类的对象
		Foo f = new Foo(10);
		f.fooF();
	}
}

在这里插入图片描述

例2.1

//Foo是一个外部类
class Foo {
	private int v1;
	
	public Foo(int v1) {
		super();
		this.v1 = v1;
	}
	
	public void fooF() {
		Bar bar = new Bar();
		bar.barF();
	}
	
	//Bar是一个局部内部类
	class Bar {
		public void barF(){
			//内部类可以直接访问外部类的数据
			//内部类的对象有一个外部类对象的引用outer,无视访问修饰符
			//outer不是java的关键字
			System.out.println(v1);
		}
	}
}

public class Day121 {
	public static void main(String[] args) {
//		//创建了一个外部类的对象
//		Foo f = new Foo(10);
//		f.fooF();
		
		//创建内部类的对象，必须有外部类的对象
		Foo f = new Foo(10);
		Foo.Bar bar = f.new Bar();// f.new Bar(); ->new Bar(f);
		bar.barF();		
	}
}

在这里插入图片描述
例2.2

//Foo是一个外部类
class Foo {
	private int v1;
	
	public Foo(int v1) {
		super();
		this.v1 = v1;
	}
	
	public void fooF() {
		Bar bar = new Bar();
		bar.barF();
	}
	
	//Bar是一个局部内部类
	class Bar {
		public void barF(){
			//内部类可以直接访问外部类的数据
			//内部类的对象有一个外部类对象的引用outer,无视访问修饰符
			//outer不是java的关键字
			System.out.println(v1);
		}
	}
}

public class Day121 {
	public static void main(String[] args) {
//		//创建了一个外部类的对象
//		Foo f = new Foo(10);
//		f.fooF();
		
		//创建内部类的对象，必须有外部类的对象
		Foo f = new Foo(10);
		//使用f.new Bar() 编译器会将f作为参数传递给Bar的构造函数
		Foo.Bar bar1 = f.new Bar();// f.new Bar(); --->  new Bar(f);
		bar1.barF();	
		
		Foo.Bar bar2 = f.new Bar();
		bar2.barF();
	}
}

在这里插入图片描述

局部内部类可以使内部类无法被外部察觉。

4.4 静态内部类

有时候使用内部类只是为了把一个类隐藏在另个一个类的内部，并不需要内部类引用外部类的对象。
这种情况可以使用静态内部类。

4.5 匿名内部类

4.6 练习

将Frock类声明为抽象类，在类中声明抽象方法calcArea方法，用来计算衣服的布料面积。
编写Shirt类继承Frock类，实现calcArea方法，用来计算衬衣所需的布料面积(尺寸 * 1.3)。
编写Coat类继承Frock类，实现calcArea方法，用来计算外套所需的布料面积(尺寸*1.5)。
编写Test类，测试calcArea方法。

/*
 *将Frock类声明为抽象类，在类中声明抽象方法calcArea方法，用来计算衣服的布料面积。
 *编写Shirt类继承Frock类，实现calcArea方法，用来计算衬衣所需的布料面积(尺寸 * 1.3)。 
 *编写Coat类继承Frock类，实现calcArea方法，用来计算外套所需的布料面积(尺寸*1.5)。
 *编写Test类，测试calcArea方法。
 */
package day11;

abstract class Frock {
	protected int size;
	protected abstract double calcArea();
	
}

class Shirt extends Frock {
	public Shirt(int size) {
		this.size = size;
		
	}
	@Override
	protected double calcArea() {
		return size * 1.3;
	}
	
}

class Coat extends Frock {
	public Coat (int size) {
		this.size = size;
	}
	@Override
	protected double calcArea() {
		return size * 1.5;
	}	
}


public class Day122 {
	public static void main(String[] args) {
		Shirt s = new Shirt(170);
		System.out.println(s.calcArea());
		
		Coat c = new Coat(180);
		System.out.println(c.calcArea());
	}
}

在这里插入图片描述

山水笑云飞
关注
专栏目录
稳稳当当学java之抽象类和接口(11)
weixin_42405054的博客
06-09 764
第十三章 抽象类和接口 1.作业回顾 1，编写一个Person类，包括属性（name、age），有参构造器、方法say(返回自我介绍的字符串）。 2.编写一个Student类，继承Person类，增加sno、score属性，以及有参构造器，在子类中调用父类的构造器。 3.编写一个方法showInfo(返回自我介绍的字符串）。 ////1.编写一个Person类，包括属性（name、age），有参构造器、方法say(返回自我介绍的字符串）。 public class Person { //属性（name、
《Java程序设计》实验5 - 类的操作、测试类
mercury8124的博客
02-27 607
《Java程序设计》实验5 - 类的操作、测试类
将Frock类声明为抽象类，尺寸在Frock类中定义，在类中声明抽象方法calcArea方法，用来计算衣服的布料面积。
Camila
07-08 773
将Frock类声明为抽象类，尺寸在Frock类中定义，在类中声明抽象方法calcArea方法，用来计算衣服的布料面积。 编写Shirt类继承Frock类，实现 calcArea方法，用来计算衬衣所需的布料面积（尺寸 * 1.3）。 编写Coat类继承Frock类，实现 calcArea方法，用来计算外套所需的布料面积（尺寸*1.5）。 编写Test类，测试calcArea方法。 public ab...
设计一个几何图形的面积计算器，希望这个计算器可以计算圆和矩形等图形的面积
Szero
04-02 2243
设计一个几何图形的面积计算器，希望这个计算器可以计算圆和矩形等图形的面积
Java【抽象类和接口】是什么？
yzhcjl_的博客
11-18 1693
记录学习过程——Java【抽象类和接口】
Java学习笔记：JDK1.8中抽象类和接口的异同
weixin_36289667的博客
04-13 699
什么是抽象类： 抽象类
【Java】抽象类和接口
trong_ 的烂笔头
08-18 3678
抽象类、接口的介绍和区别
Java的抽象类和接口
weixin_73616913的博客
03-28 2175
对于面向对象编程来说，抽象是它的一大特征之一。在 Java 中，可以通过两种形式来体现 OOP 的抽象：接口和抽象类。这两者有太多相似的地方，又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用，但是实际则不然。今天我们就一起来学习一下Java中的接口和抽象类。抽象方法必须用 abstract 关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用 abstract 关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
java学习笔记接口和抽象类
08-23
java学习笔记接口和抽象类
Java-抽象类和接口--学习笔记.docx
07-05
在本篇Java学习笔记中，我们将深入探讨这两个概念及其作用。 首先，我们来看抽象类。抽象类是那些包含了至少一个抽象方法的类。抽象方法是一种只有方法签名而没有具体实现的方法，它使用`abstract`关键字来标识。...
抽象类与接口（学习笔记）
12-21
抽象类和接口是Java编程语言中两种重要的抽象概念，它们都是用于实现多态性和封装的机制，但有着明显的区别。 **抽象类** 是一个不能被实例化的类，它定义了一组公共属性和行为，用于共享相似特征的类。抽象类通过`...
学习黑马教程java笔记之抽象类和接口
qq_57039493的博客
11-26 197
抽象类和接口 抽象类 什么是抽象类？ 抽象类简单理解，就是这个对象是什么。人和狗的抽象类都是动物。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。 抽象类的规则 1 抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。 2 抽象类不能被实例化，无法使用new关键字来调用抽象类的
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真 功能：实现并联系统中各逆变器输出
最新发布
10-09
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真。 功能：实现并联系统中各逆变器输出功率均分。 （有能力的话还可以研究下垂特性、功率指令以及静态功工作点三者之间的联系） 控制策略：VSG控制策略（同步机控制） 逆变器主电路：三相逆变器，LCL滤波电路，VSG控制模块。 VSG控制模块：定、转子方程，dq变，电压电流双闭环，预同步，pwm发生器。
Ringtones波点音乐-《Lightning Moment》.mp3
10-09
Ringtones波点音乐-《Lightning Moment》.mp3
onnx2onnx-0.3.1.tar.gz
10-09
onnx2onnx-0.3.1.tar
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-09
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
实现卡尔曼滤波器,扩展卡尔曼滤波器,双卡尔曼滤波器和平方根卡尔曼滤波器Matlab代码.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
RATIONALYST：预训练过程监督改进推理机制
10-09
内容概要：RATIONALYST 是一种预训练推理模型，旨在改进大型语言模型（LLMs）在处理数学、常识、科学和逻辑推理等多种任务时的表现。通过对来自大规模未标注数据集中提取的隐含推理论据进行训练，解决了传统模型在模拟日常沟通中的逻辑跳跃而带来的推理由不足的问题。相较于现有的同类系统，如GPT-4及其他相同大小或更大的验证模型，RATIONALYST 在七个典型的基准测试上表现得更好。 适合人群：自然语言处理研究员与高级工程师。 使用场景及目标：研究者可以利用 RATIONALYST 提高对复杂语言和逻辑的理解能力，从而在不同的应用场景下提升系统的准确度和稳定性。 其他说明：本论文还附带发布了 GitHub 上该项目的所有代码，可供下载用于继续探索或者作为教学材料帮助相关人员更好地理解这一新的方法和技术路径。
Java学习笔记：抽象类与接口解析
"稳稳当当学java之抽象类和接口(11)——关于java基础中抽象类和接口的学习笔记，包含作业回顾、继承规则、方法重写、多态、final修饰符、抽象类和接口的讲解及练习案例。" 在Java编程中，抽象类和接口是面向对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值