Java抽象类

day092022年9月19日08:35:20

课前回顾

1、封装：将细节隐藏起来，对外提供公共的接口
2、private
3、get/set
4、无参构造、有参构造
5、this关键字
6、JavaBean
7、继承：extends
8、重写

课前回顾具体内容信息

课前回顾:
  1.什么是封装:将细节隐藏起来,对外提供公共的接口
  2.关键字:private 私有
  3.被private修饰的成员特点:别的类不能直接访问
  4.get/set:
    get:获取属性值
    set:为属性赋值
  5.无参构造:
    a.格式:
      public 类名(){
          
      }
    b.作用:new对象
    c.特点:
      每个类都有一个jvm默认提供好的空参构造,不写也有
  6.有参构造:
    a.格式:
      public 类名(参数){
          为属性赋值
      }
    b.作用:
      new对象
      为属性赋值
    c.如果写了有参构造,jvm不再提供无参构造了,建议,都写上
  7.this关键字:
    a.概述:代表当前对象,哪个对象调用的this所在的方法,this就代表哪个对象
    b.作用:区分重名的成员变量和局部变量
  8.标准的javabean:属性私有,构造方法,get/set
  9.生成标准javabean的快捷键:alt+insert
  10.继承
     a.关键字:extends
             子类 extends 父类
     b.子类可以继承父类中私有和非私有成员,但是不能使用私有成员的
       构造方法不能被继承,也不能被重写
       静态方法不能被重写
     c.成员访问特点:
       成员变量:看等号左边是谁,先调用谁
       成员方法:看new的是谁,先调用谁
  11.方法的重写:
     a.概述:子类中有一个和父类方法名,参数列表一样的方法
     b.注解:@Override -> 检测此方法是否为重写的方法
     c.方法重写的注意事项:
       子类重写父类方法之后,权限要大于等于父类权限
       子类重写父类方法之后,返回值类型应该是父类方法返回值类型的子类
       子类重写的方法要和父类中的方法,从方法名上,参数列表上都要一致
       私有方法不能重写,构造方法不能重写,静态方法不能重写  
     d.使用场景:功能的升级改造  
​
今日重点:
  1.会使用super调用父类成员
  2.会使用this调用本类成员
  3.会使用静态代码块以及知道静态代码块的执行特点
  4.会定义抽象类和抽象方法会重写实现抽象方法
  5.多态的所有
  6.会自定义类型作为方法的参数和返回值使用

第一章：继承

1、继承中构造方法的特点

1、初始子类对象时，会先调用父类无参构造
2、原因：每个构造方法中的第一行都会有一个super()
super() -> 父类空参构造方法 
即使不写也是默认存在的。。。

2、super和this的具体使用

2.1 super的使用

1、super()代表着父类引用 作用：调用父类中的成员
2、使用
a.调用父类构造方法
在子类中调用父类构造方法
super()：代表的是调用的是父类的空参构造方法，如果不写的话，会默认调用
super(参数)：调用的是父类中的有参构造方法
注：在子类的构造方法中，默认是调用父类的空参构造方法，可以写或者不写，但是如果调用了有参构造，只能把有参构造方法写在第一行，不能空参构造方法、有参构造方法都写，因为他们不能同时写，不能都放在第一行，空参构造即使没写，但是也是调用了....
​
b.
c.

2.2 this的使用

1、this：代表着当前对象
2、调用构造方法
a.this():表示调用当前对象的空参构造方法
this(参数): 表示调用当前对象的有参构造方法
注：可以在空参构造方法中调用有参构造法方法，也可以在有参构造方法中调用空参构造方法，
但是！！！！ 不能同时在看，空参构造方法中调用了有参构造方法，又在有参构造方法中调用了空参构造方法
3、this.成员方法名(参数):表示调用当前对象的成员方法，通常情况下都是不写this的
4、this.成员变量：表示调用当前对象的成员变量，通常情况下都是不写static的
5、注意：
a.使用this构造器，必须放在第一行
b.this和super不能出现在构造方法中，原因：因为都要放在第一行，如果都出现的话，没办法决定谁在第一行，然后就报错了

3、继承的特点

1、一个子类只能有一个亲爹
一个子类只能有一个直接父类，可以有多个父类，object是所有类的间接父类（也是一些类的直接父类，这句话说的可能不是特别准确，懂都懂。。。）就是所谓的多层继承
public class A{}
public calss B extends A{}
public class C extends B{}
A是B的直接父类
B是C的直接父类
A是C的间接父类
​

第二章：代码块

2.1、构造代码块

1、格式
{
    代码;
}
2、执行特点
优先于构造方法执行，没New一次就会执行一次(每创建一个新的对象就会执行一次这个代码块)
​

2.2、静态代码块

1、格式
static {
    代码;
}
2、执行特点
优先于构造方法和构造代码块的执行，而且只执行一次
注：静态代码块的执行一次是：在第一次创建对象时执行一次，以后无论创建多个少个对象，也就是所谓的无论New多少次，这个代码块也只是执行一次。

2.3、执行顺序

静态代码块 ---->>>> 构造代码块 ---->>>> 构造方法

2.4、静态代码块的使用场景

1、初始化一些数据，这些数据需要最先执行，而且只执行一次即可
ex:比如数据库的连接等

第三章：抽象

3.1、抽象方法的介绍

1、介绍
将共有的方法抽取出来，但是没法实现，需要延伸到子类中实现(得去子类中实现具体的功能)，这样的方法就可以定义成抽象方法，抽象方法所在的类一定是抽象类

2、抽象类和抽象方法之间的关系：
a.抽象方法所在的类一定是抽象类
b.抽象类中不一定含有抽象方法

3、关键字 ： abstract

4、定义抽象类：
public abstract calss 类名{}

5、定义抽象方法
权限修饰符 abstract 返回值类型 方法名(参数); //没有方法体，是因为需要到子类中具体实现

6、"抽象" 是一种思想，并不是一种"技术" 一种设计理念，也可以理解成一种规范。
解释(根据自己的理解)：将共同的方法抽取出来，但是并没有去具体实现，那就说明如果满足这一类共同的方法就可以归结到一起，那么你这个类就可以有这个方法，然后你需要在你这个类中再去实现具体的功能，那么在你实现具体功能是这就是重写了父类的方法。

7、父类中的抽象方法，子类继承以后，必须重写。
可以理解为，你只有重写以后才可以去实现你具体的功能，毕竟父类中只是定义了一个抽象方法，甚至连方法体都没有，那既然想要实现具体的功能，而且是针对你的这个类，那肯定的重写，所以子类继承父类以后必须重写抽象方法。

3.2、抽象使用注意事项

1、抽象类不能直接new对象，只能创建非抽象类的对象
2、抽象类中可以有构造方法,是供子类创建对象时，初始化父类属性使用的
3、抽象类中可以有成员变量、构造、成员方法
4、抽象方法一定在抽象类中，但是抽象类中可以没有抽象方法
5、抽象类的子类，必须重写父类中的所有的抽象方法，否则，编译无法通过，除非该子类也是一个抽象类
理解：抽象类的子类，在没有重写所有的抽象方法是只能定义抽象类，要么就重写了全部的抽象方法，没有别的选择

第四章：多态

4.1、多态如何学习

1、知道多态的前提
2、知道如何用多态的方式new对象 父类 对象名 = new 子类对象();
3、多态前提下，成员的访问特点、
4、多态的好处 拓展性强
5、多态向下转型(将父类类型转换成子类类型---->>>>强转)

4.2、多态的介绍

1、前提
a.必须有子父类继承关系或者接口实现关系
b.必须有方法的重写，没有方法的重写，多态没有意义(多态是针对于成员方法，成员变量没有多态)
c.父类引用执行子类对象
父类类型 对象名 = new 子类对象() ex double a = 10;

2、缺点
不能调用子类中特有的功能

4.3、多态的基本使用

1、定义一个父类
2、定义一个子类继承父类，重写父类的方法
3、new对象时：父类引用执行子类对象
4、调用重写方法

4.4、多态条件下成员的访问特点

4.4.1、 成员变量

看等号左边是谁，先调用谁中的成员变量，子类没有去父类中找
理解：自己总结的
关于成员成员变量的值，看等号左边是什么类型就去找谁的成员变量的值，如果是子类类型，那就先去找子类的值，没找到就去父类找，如果是父类类型那就是父类的值，切记，成员变量和多态没关系就行，爱咋咋地。
我感觉一般都是父类的值，你想呀，既然是多态，那么肯定等号左边的类型是父类类型，等号右边是new的子类类型，就直接找父类的值就行，trust me
成员变量：多态关我鸡毛事

4.4.2、成员方法

看new的是谁，先调用谁中的方法，子类没有找父类
我个人建议，我瞎说哦：既然是多态，那么等号左边肯定是父类类型 然后new的是子类类型对吧，还有就是多态玩的重写方法，那么肯定调用的是子类重写的方法，运行的也是子类中重写的方法，(否则就失去了多态的意义)子类中没有去父类找。

4.4.3、个人总结

出现了多态
成员变量值：就看等号左边的类型 然后找到对应的成员变量，就是成员变量的值
成员方法：就看new的谁，调用new对象的成员方法就行
你就这么来肯定没错

4.5、多态的优缺点

1、多态的好处不仅仅体现在new对象上，而是体现在方法参数传递上
2、优点：扩展性强
缺点：不能直接调用子类特有的功能

4.6、多态的转型

4.6.1、向上转型

多态默认的:
父类引用指向子类对象
父类类型 对象名 = new 子类对象()

说白了就是小类型自动提升为大类型，这样理解：父类型为大类型，子类型为小类型就行
多态就是把子类类型转换成了父类类型

4.6.1、向下转型

1、父类类型 对象名 = new 子类对象() ex double b = 10; 就是将整形的10提升为double类型了
2、向下转型就是：将父类类型转换成子类类型 说白了就是大类型转换成小类型 强转呗
子类类型 对象名 = (子类类型)对象名; int a = (int)b; 那不就是将double的10.0又转化成了10(int类型的)

4.7、转型时出现的问题

一个父类可能有多个子类，子类可以强转成父类，但是子类之间尤其是那些直接继承父类的子类(那些直接父类是父类的类，这句话可能有点绕，你理解下)是不能强转的，否则会报错：ClassCastException -> 类型转换异常 -> 等号左右两边类型不一致

4.7.1 关键字 instanceof

1、使用 
对象名 instanceof 类型
判断对象是否属于关键字后面的类型
结果：boolean类型 true或false

第五章：自定义类型作为方法的参数和返回值

总结：自定义类型既可以做参数也可以做返回值，但是得注意
注意：1、参数和返回值都是引用数据类型时，传递和返回的都是对象，所谓的地址值
2、如果参数和返回值是抽象数据类型，那么我们需要传递或接收的是他的非抽象子类对象，因为抽象类不能创建对象

第六章：final关键字使用

1、final：最终的
2、可以修饰：类、方法、成员变量、局部变量、对象

6.1、final修饰类

public final class 类名{}
final修饰的类不能被继承

6.2、final修饰方法

权限修饰符 final 返回值类型 方法名(参数列表){
	方法体;
	return 结果;
}
final修饰的方法不能重写
final和abstract不能一起使用
原因：final修饰方法不能被重写，而abstract修饰的方法必须重写，一个不能重写，一个必须重写矛盾了

6.3、final修饰局部变量

final 数据类型 变量名;
被final修饰的局部变量不能二次赋值，相当于常量；

6.4 final修饰对象

final 类名 对象名  = new 类名();
被final修饰的对象，地址值不能改变，但是属性值可以变
ex 你的媳妇不会变，但是他的年龄会变

6.5、final修饰成员变量

final 数据类型 变量名 = 数据类型的值;
public class Person{
	final String name = "大郎";
	
}

被final修饰的成员变量不能二次赋值

第七章：权限修饰符

7.1不同权限的访问能力

public：公共的,最高权限,被public修饰的成员,在哪里都能访问
protected：受保护的
default：:默认的 注意  不写权限修饰符就是默认权限,不能直接把default写出来
private：私有的,只能在自己的类中直接访问

	public	protected	default（空的）	private
同类	yes	yes	yes	yes
同包不同类	yes	yes	yes	no
不同包子父类关系	yes	yes	no	no
不同包非子父类关系	yes	no	no	no

public具有最大权限,private有最小权限

7.1.1 编写代码时,如果没有特殊的考虑,建议这样使用权限

1.构造:public的   new对象用
2.成员方法:public的  方便调用
3.成员变量:private 的   封装思想