Day_12_多态、Object、抽象、接口

最新推荐文章于 2024-08-12 16:47:32 发布

势不可挡の内鬼

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量77

点赞数

分类专栏：学习日志文章标签： java eclipse

本文链接：https://blog.csdn.net/m0_51589970/article/details/120773002

版权

学习日志专栏收录该内容

52 篇文章 0 订阅

订阅专栏

1.软件设计六大原则 :

1)单一职责原则 : 功能单一,之拥抱一种变化
   一个方法只负责一件事,这样该方法进行改动的时候,不会影响其他程序,几乎所有程序员都在遵循这个原则
   优点 : 降低类之间的耦合度,提高可读性,增加可维护性和可扩展性,降低可变性的风险

   2)里氏替换原则 : 所有可以使用父类的地方,一定可以使用子类

   3)依赖倒置原则 : 高层通过抽象依赖底层,细节应该依赖于抽象

   4)接口隔离原则 :

   5)迪米特原则 : 也称为最少知识原则
   一个类尽量减少自己对其他类的依赖,原则就是低耦合,高内聚

   6)开闭原则 : 对修改关闭,对扩展开放

2. 多态 :

父类引用指向子类对象
   父类引用 : 使用父类声明的引用类型变量
   指向 : 就是通过这个变量可以找到谁
   使用父类声明的变量,可以找到子类对象
   Animal a = new Animal();
   Animal a = new Cat(); 多态

2.1 多态的几种形式 :

1.直接多态 Animal a = new Animal();
   2.形参和实参 : 方法声明时,参数列表需要接收父类类型,而方法调用时,传入子类对象
   public static void m1(Animal a){}
   m1(new Cat());
   3.返回值 : 返回值类型是父类类型,但是返回的对象是子类对象
   public static Animal m2(){
   return new Cat();
   }

2.2 多态缺点 : 丢失子类特有的属性

          使用多态进行调用 :
   1 如果父类没有,不管子类有没有,都报错,因为丢失子类特有属性
   2 如果父类有,子类没有,使用父类的,因为继承
   3 如果父类有,子类也有,除了成员方法执行子类,其他都执行父类的(因为成员方法可以覆写)

public class Poly_01 {
	public static void main(String[] args) {
		Animal a = new  Cat();
		a.eat();
	}

}
class Animal{
	public void eat() {
		System.out.println("吃饭...");
	}
}
class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

2.3 优点

高内聚，低耦合

public class Poly_02 {
	public static void main(String[] args) {
		Cat_01 c = new Cat_01();
		eat(c);
		Dog_01 d = new Dog_01();
		eat(d);
		Pig p = new Pig();
		eat(p);
	}

	public static void eat(Animal_01 a) {
		a.eat();
	}
}

class Animal_01 {
	public void eat() {
	}
}

class Cat_01 extends Animal_01 {
	int age = 2;

	public void eat() {
		System.out.println("猫吃鱼");
	}
}

class Dog_01 extends Animal_01 {
	int age = 3;

	public void eat() {
		System.out.println("狗吃肉");
	}
}

class Pig extends Animal_01 {
	@Override
	public void eat() {
		System.out.println("吃白菜");
	}
}

2.4 隐秘多态

通过子类,调用了父类的方法的时候,父类的这个方法的上下文环境,就是多态环境(属于父类空间,子类对象)

public class Poly_04 {

	public static void main(String[] args) {
		Sup sup = new Sub();
		// 2
		System.out.println(sup.i);
		// 子类
		sup.m2();

		Sub sub = new Sub();
		// 3
		// System.out.println(sub.i);
		// 子类
		// sub.m2();
		sub.m1();
	}
}

class Sup {
	int i = 2;
	public void m1() {
		System.out.println(this.i);
		this.m2();
	}

	public void m2() {
		System.out.println("父类的m2");
	}
}

class Sub extends Sup {
	int i = 3;

	public void m2() {
		System.out.println("子类的m2");
	}
}

2.5 Instanceof

多态又叫向上转型,子类到父类是向上转型 , 父类到子类是向下转型

因为多态会丢失子类特有的属性,想要调用子类特有属性的时候,需要转换为对应的子类类型才行

public class Poly_05 {
	public static void main(String[] args) {
		Animal_01 a = new Cat_01();
		// 调用不了,丢失特有属性
		// System.out.println(a.age);
		m1(a);
		// 假如传递一个Dog类型,就会报错
		a = new Dog_01();
		m1(a);
	}

	public static void m1(Animal_01 a) {
		// instanceof : 判断某个对象是否由某个类实例化而来
		if (a instanceof Cat_01) {
			Cat_01 c = (Cat_01) a;
			System.out.println(c.age);
		} else {
			Dog_01 c = (Dog_01) a;
			System.out.println(c.age);
		}
	}
}

3. Abstract

abstract 是个修饰符

修饰的类是抽象类, 不能创建对象,只是用于被继承
修饰的方法是抽象方法,并且该方法没有方法体(也就是{})
抽象方法必须在抽象类中,但是抽象类中不一定有抽象方法

  abstract和final 是二选一 , 因为final修饰的类不能被继承,成员方法不能被覆写
而 abstract修饰的抽象类就是用来被继承的,抽象方法就是用来被覆写实现的

  一个非抽象类继承一个抽象类,需要实现所有的抽象方法
  一个抽象类继承一个抽象类需要实现0~N个抽象方法

  抽象类虽然不能创建对象,但是有构造方法,用于子类创建对象时调用

public class Abstract_01 {
	public static void main(String[] args) {
		// Animal animal = new Animal();
		Animal a = new Cat();
		a.eat();
	}
}
abstract class Animal{
	public Animal(){
		System.out.println("父类构造");
	}
	public abstract void eat();
}
class Cat extends Animal{
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

class Dog extends Animal{
	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}
}

注意：abstract和final不能同时出现

3. Interface

interface : 定义接口关键字语法 : [权限修饰符] interface 接口名 { 类体 }

接口主要为了解决java中单继承功能变弱问题,一个类只能继承一个类,但是可以实现多个接口

  1.8之前接口是完全抽象的,只能有抽象方法和常量

  1.8开始接口中允许出现默认方法和静态方法

  1.语法 [权限修饰符] interface 接口名 { 类体 }
  2.接口中默认都是public的
   接口中的变量都是常量,并且 public static final 可以省略,默认就是
   接口中的抽象方法,public abstract 可以省略,默认就是
  3.接口没有构造方法,同时不能创建对象
  4.一个类只能继承一个类,但是可以实现多个接口
   [权限控制修饰符] class 类名 implements 接口名1,接口名2,....{}
   一个类实现接口,必须实现接口中所有的抽象方法
   一个抽象类,实现接口,需要实现0~N个抽象方法
  5.接口和接口之间是多继承,多个以逗号隔开
   [权限控制] interface 接口名 extends 父接口名1, 父接口名2,....{}

  6.1.8开始可以有静态方法和default方法(default方法就可以理解为成员方法,子实现类也可以覆写)
   静态方法调用 : 接口名.方法名(参数);
   默认方法调用 : 需要用子实现类对象.方法名(参数);
              1.9 开始就开始支持private方法

public interface Interface_01 {
	// 接口中没有变量,只有常量
	public static final int xxx = 2;
	// public static final 可以省略,默认就是
	int aaaa = 3;

	// 抽象方法
	public abstract void m1();

	// public abstract 可以省略,默认就是
	void m2();

	// 静态方法
	public static void m3() {
		System.out.println("静态方法");
	}

	// 默认方法
	default void m4() {
		System.out.println("默认方法");
	}
}
interface A{
	void m1();
}
interface B{
	void m2();
}
interface C{
	void m3();
}
interface D extends A,B,C{
	void m4();
}
class E  implements A,C{

	@Override
	public void m3() {
	}
	@Override
	public void m1() {
	}
	
}

3.1优点

当一个功能拥有多种不同实现的时候,就需要依赖接口编程,此时可以降低耦合度

如果说一个功能,只拥抱一种变化,就不需要使用接口了

还可以使用多态

注意：如果接口和抽象类都能完成一件事,那么优先使用接口，因为类和接口是多实现,类和类是单继承这样还能保留类的继承

势不可挡の内鬼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day_12_多态、Object、抽象、接口

1.软件设计六大原则 : 1)单一职责原则 : 功能单一,之拥抱一种变化一个方法只负责一件事,这样该方法进行改动的时候,不会影响其他程序,几乎所有程序员都在遵循这个原则优点 : 降低类之间的耦合度,提高可读性,增加可维护性和可扩展性,降低可变性的风险 2 里氏替换原则 : 所有可以使用父类的地方,一定可以使用子类 ...
复制链接

扫一扫