【无标题】

最新推荐文章于 2024-08-28 18:00:38 发布

KDLG_LG

最新推荐文章于 2024-08-28 18:00:38 发布

阅读量52

点赞数

文章标签： linq c# android

本文链接：https://blog.csdn.net/kdlg_lg/article/details/122459829

版权

1. Final

1.1 定义

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

1.2 作用

1.final修饰的类，不能被继承

final class A{
}
class B extend A{
}

2.final的成员方法,不能被覆写

class A{
public final voidm1(){

}
}
class B extends A{
@Override
public voidm1(){
}
}

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

class A{
public final void m();1{
}
}
class B extends A{
@Override
public void m1(){
}
}

1.3 修饰引用类型

final Customer c = new Customer("张三", 18);

c 加final 修饰了，不能更改，name和age没有用final修饰，可以更改

c是地址，不可以修改，通过地址找到的堆内存的只可以修改

2. 多态

2.1 定义

父类引用指向子类对象

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

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

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

子类变量=new 子类();
Cat c=new Cat();

父亲类型变量名=new 子类();
Animal a=new Cat();

2.2 先关知识

软件设计六大原则：1.单一职责原则：功能单一，只拥抱一种变化
2.里氏替换原则：能使用父类的情况下，一定可以使用子类，因为继承，父类有的功能，子类都有
3.依赖倒置原则：细节应该依赖抽象，而抽象不应该依赖细节
4.接口隔离原则
5. 迪米特法则：最少知识原则，和其他类或对象，尽可能有更少的了解
6.开闭原则：对修改关闭，对扩展开放

2.3 优点

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

当一件事会有多种不同实现方式的时候,我们选择依赖高层,来拥抱多种变化
本质还是降低类和细节之间的耦合度

需求 : 要求能够接收Cat对象,并调用该对象的eat方法
         public static void test(Cat cat){
         cat.eat();
         }

新增需求 : 要求能够接收Dog对象,并调用该对象的eat方法
         public static void test(Dog dog){
         dog.eat();
         }

需求 : 要求能够接收所有的动物,并调用该对象的eat方法
public static void test(Animal a) {
a.eat();

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();
   }

多态进行属性调用 :

1 如果父类没有 ,直接报错,不管子类有没有

2 如果父类有,子类没有, 直接执行父类

3 父类和子类都有, 成员方法执行子类,因为成员方法可以覆写,其他的都执行父类

多态又叫向上转型

由于多态原因,子类特有属性访问不到,想要访问也行,先进行向下转型
必须先发生向上转型,才能发生向下转型
SubClass sub = (SubClass) sup;
sub.m2();

没有发生向上转型,如果直接使用向下转型会报错
SupClass sup1 = new SupClass();
SubClass sub1 = (SubClass) sup1;

2.6 多态的几种形式

1.直接多态
       Sup sup = new Sub();
2.形参和实参,方法参数列表为父类类型,调用方法传入子类对象
       m1(new Sub());
3.返回值多态,返回值类型是父类类型,但是返回子类对象
       Sup result = m2();

2.7 Instanceof

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

如果是在向下转型,不是就不转,可以避免类型转换异常

if ( sup1 instanceof SubClass) {
SubClass sub1 = (SubClass) sup1;
}

3. abstract

3.1 定义

abstract : 修饰符,修饰的类是抽象类,修饰的方法是抽象方法

抽象类,不能实例化对象
抽象方法,没有方法体,只定义功能,没有功能的实现,并且抽象方法必须在抽象类中
反之,抽象类中,可以没有抽象方法

abstract不能和final 同时出现

3.2 使用语法

4. Interface

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

语法修饰符 interface 接口名 {}
接口中的抽象方法,不需要加abstract修饰 , 方法默认都是 public abstract
接口中,没有变量,只有常量,并且 public static final 可以省略

public static final String name ="xx";

String name ="xx";

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

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

一个类只能继承一个类,但是可以实现 N个接口,以逗号隔开,可以解决单继承功能变弱问题
class 类名 implements 接口1 , 接口2,接口3....{}

接口和接口之间,是多继承, 多个已逗号隔开
interface 接口名 extends 父接口名1,父接口名2,...{}

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

abstract class E implements A,B,C{
}

1.7 只能有抽象方法
1.8 可以有静态方法,也可以有default方法(就理解为成员方法即可)
静态方法,用接口名调用即可
default 方法需要同过子实现类调用,同时也可以覆写
1.9 开始支持 private方法

5. Object

5.1 概述

Object 是所有类的祖类,是java中提供的根类
一个类没有显示继承另一个类的时候,默认继承object
Object xx = new xxx() : 是可以发生多态的

5.2 Equals

== : 比较基本类型的时候,比较值的大小,但是比较引用类型的时候,比较的是内存地址
而比较内存地址,是没有任何价值的,我们一般会比较两个对象的属性值,是否一致,而不是比较两个对象地址是否一致
equals() : 该方法设计目的,用来比较两个对象是否相等,但是默认比较地址
java中Object里面的equals方法,默认比较内存地址(==) 需要我们根据需求进行重写

5.3 Finalize

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

5.4 toString

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

public class toString_01 {
   public static void main(String[] args) {
       Person p1 = new Person("张三", 18);
       System.out.println(p1);
       System.out.println(p1.name + ":" + p1.age);
   }
}

class Person {
   public String toString() {
       return this.name + ":" + this.age;
   };

String name;
int age;

   public Person(String name, int age) {
       super();
       this.name = name;
       this.age = age;
   }

}