Day-12-多态

最新推荐文章于 2024-09-25 10:59:43 发布

t17246

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量79

点赞数

文章标签： java eclipse

本文链接：https://blog.csdn.net/t17246/article/details/122449726

版权

1 Final

1.1 final 是个修饰符，表示最终的，不可更改的

2 能做什么

final修饰的类，不能被继承

final修饰的成员方法，不能被覆写

final修饰的变量不能二次赋值，没有默认值，必须显示赋值

一般我们把final修饰的静态变量叫做常量，public static final 数据类型变量名 = 值；

1.3使用

2多态

2.1 是什么

父类引用指向子类对象

父类引用：指的是用父类型声明的引用型变量

指向：通过内存地址可以找到哪个对象

子类对象：new 子类创建的堆内存对象

子类变量 = new 子类（）；

Cat c = new Cat();

父类类型变量名 = new 子类（）；

Animal a = new Cat();

2.2相关知识

软件设计六大原则 :

1 单一职责原则 : 功能单一,只拥抱一种变化

2 里氏替换原则 : 能使用父类的情况下,一定可以使用子类

因为继承,父类有的功能,子类都有

3 依赖倒置原则 : 细节应该依赖抽象,而抽象不应该依赖细节

4 接口隔离原则 : 先不管

5 迪米特法则 : 最少知识原则,和其他类或对象,尽可能有更少的了解

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

2.3 优点：

同一操作，作用域不同对象，可以有不同的解释，产生不同的结果，就是多态性

当一件事会有多种不同实现方式的时候,我们选择依赖高层,来拥抱多种变化

本质还是降低类和细节之间的耦合度

2.4缺点

丢失子类特有的属性

2.5适用语法

public static void main(String[] args){
		Cat c = new Cat();
		//多态
		Animal a = new Cat();
		a.eat();
		a = new Dog();
		a.eat();
	}

2.6 多态的集中形式

public class Poly_04 {
		public static void main(String[] args){
			// 1直接多态
			Sup sup = new Sub();
			//2 形参和实参，方法参数列表为父类类型,调用方法转入子类对象
			m1(new Sub());
			//3  返回值多态,返回值类型是父类类型,但是返回子类对象
			Sup result = m2();
		}
		public static Sup m2(){
			return new Sub();
		}
		public static void m1(Sup sup){
			
		}
}
class Sup{
	
}
class Sub extends Sup{
	
}

2.7 Instanceof

判断某个对象是否由某个类实例化而来

if（sup1 instanceof SubClass）{

//如果是，在向下转型，不是就不转，可避免类型转换

SubClass sub1 = (SubClass) sup1;

}

3 abstract

3.1 是什么

bstract: 修饰符修饰的类是抽象类，修饰的方法是抽象方法
抽象类不能实例化对象
抽象方法没有方法体，只定义功能，没有功能的实现，并且抽象方法必须在抽象类中
反之，抽象类中可以没有抽象方法
abstract不能和final同时出现

3.2使用语法

abstract class Animals{
	//动物吃饭的功能
	public abstract void eat();
	public void m1(){
		
	}
}
class Bird extends Animals{

	@Override
	public void eat() {
		System.out.println("鸟吃虫子");
		
	} 
}
class Fish extends Animals{

	@Override
	public void eat() {
		System.out.println("大鱼吃小鱼");
		
	}
	
}

4 Interface

4.1是什么

接口可以理解为完全抽象的一个类,里面只有抽象方法和常量

但是从1.8开始,允许出现静态方法和默认方法

语法修饰符 interface 接口名 {}

接口中的抽象方法,不需要加abstract修饰 , 方法默认都是 public abstract

接口中,没有变量,只有常量,并且 public static final 可以省略

类和接口之间,不再是继承关系,变成了实现关系,由extends 换成了 implements

接口名变量 = new 子实现类() 也是会发生多态的

一个类只能继承一个类,但是可以实现 N个接口,以逗号隔开,可以解决单继承功能变弱问题

class 类名 implements 接口1 , 接口2,接口3....{}

接口和接口之间,是多继承, 多个已逗号隔开

interface 接口名 extends 父接口名1,父接口名2,...{}

一个类如果实现了一个接口,那么必须实现接口中所有的抽象方法,.否则该类需要加abstract修饰

一个抽象类,实现一个接口,可以实现 0~N个抽象方法

1.7 只能有抽象方法

1.8 可以有静态方法,也可以有default方法(就理解为成员方法即可)

静态方法,用接口名调用即可

default 方法需要同过子实现类调用,同时也可以覆写

1.9 开始支持 private方法

4.2使用方法

interface A{
		public static final String name = "xx";
		//psf 可省略
		int age =3;
		
		public abstract void m1();
		//public 和abstract可以省略
		void m2();
		public default void m3(){
			System.out.println("默认方法");
		}
		public static void m4(){
			System.out.println("静态方法");
		}
}
interface B{
	
}
//多继承
interface C extends B,A{
	
}
//多实现，需要实现所有的抽象方法
class D implements A,B,C{

	@Override
	public void m1() {
		// TODO Auto-generated method stub	
	}
	@Override
	public void m2() {
		// TODO Auto-generated method stub	
	}
	}
//抽象类,可以实现0~N个抽象方法
abstract class E implements A,B,C{
	
}

5 Object

5.1 Equals

Object 是所有类的祖类，是java中提供的根类
一个类没有显示继承另一个类的时候，默认继承object
Object xx = new xxx（）；是可以发生多态的
== 比较基本类型的时候，比较直的大小，但是比较引用类型的时候，比较的是内存地址
而比较内存地址，是没有任何价值的，我们一般会比较俩个对象的属性值，是否一致，而不是比较俩个对象地址是否一致
equals() : 该方法设计目的，用来比较俩个对象是否相等，但是默认比较地址
java中Object里面的equals方法，默认比较内存地址（==）需要我们根据需求进行填写

public static void main(String[] args){
		Student s1  = new Student(1,"张三");
		Student s2  = new Student(1,"张三");
		//false
		System.out.println(s1 == s2);
		System.out.println(s1.equals(s2));
	}
	
}
class Student{
	int id;
	String name;
	public Student(int id, String name){
		super();
		this.id = id;
		this.name = name;
	}
		// 需求 : 如果两个学生的ID相同 就认为这两个是同一个学生
		// 需求 : 如果两个学生的ID和姓名都相同 就认为这两个是同一个学生
	public boolean equals(Object obj){
		//判断是不是同一个对象
		if(this == obj){
			return true;
		}
		//向下转型
		if(obj instanceof Student){
			Student s2 = (Student) obj;
			// String类中 覆写了equals方法,比较的是值
			if(this.id == s2.id&&this.name.equals(s2.name)){
				return true;
			}
		}
		return false;
	}
}

5.2Finalize

finalize : 该方法会在垃圾被回收的时候自动调用,无序程序员手动调用
垃圾 : 当一个对象,没有更多引用指向它的时候,该对象被视为垃圾数据(就是创建了一个对象,谁也找不到他)
protected void finalize() throws Throwable { }
Object中的finalize方法,什么也没有做,需要自己根据需求进行重写

public static void main(String[] args){
		Person p = new Person();
		//finalize  方法没有回收功能。，手动调用的话，只是单纯的方法调用
		//p.finalize();
		p= null;
		
	}

}
class Person{
	public void finalize(){
		System.out.println(this + "我要被回收了");
	}

5.3toString

toString: 代表了当前对象的字符串表示形式
当我们打印一个引用型变量的时候，会自动调用该对象的toString方法
而 Object 中默认的toString 方法是打印该对象的内存地址（hash值）

public class ToString {
	public static void main(String[] args){
		Person1 a1 = new Person1("李四",10);
		System.out.println(a1.name + "." + a1.age);
		System.out.print(a1);
	}
}
class Person1{
	public String toString(){
		return this.name + "." + this.age;
	}
	String name; 
	int age;
	
	public Person1(String name, int age){
		super();
		this.name = name;
		this.age = age;
	}
}