小白JAVA学习第三周总结

day1

一，关键字static

1 基本概念：表示该属性是多个对象共享，共用的

2 特点：

1)随着类的加载而加载

2)优先于对象存在: 它不能this共存 (this:代表当期类对象的地址值引用)

对象还没有new的时候,当前被static修饰的成员就已经内存了

3)被静态修饰的 可以被多个对象共享:有共享共用的意思

• 举例:

• 饮水机中的水(适合)

• 水杯共享(不适合!)

  4)被静态修饰的变量,方法----->静态变量或者静态方法

  我们所说的成员变量和成员方法:都指的是非静态

  静态的成员的访问方式:

  类名.变量

  类名.方法名()

  3 注意事项

  1)非静态的方法既可以访问静态变量,也可以访问非静态的变量

  既可以调用静态方法,也可以调用非静态方法

  2)静态的方法: 只能访问静态变量，调用静态方法 （简单记:静态只能访问静态）

  二，代码块

  在Java中,使用{}包裹棋起来的内容,成为代码块!

  1)分类：

  局部代码块 :在方法定义中使用 ,作用:限定局部变量的生命周期

  构造代码块:在类的成员位置(类中,方法外),使用{}包裹起来 作用:给类中的一些成员进行数据初始化

  特点:每次在执行构造方法之前,如果存在构造代码块,先执行构造代码块中的内容!

  静态代码块:

  在类的成员位置,直接使用 static{},特点:随着类的加载而加载,优先于对象存在!

  作用:也可以通过static代码块,对一些操作(后期IO流创建文件/JDBC(Java链接数据库注册驱动))

  静态代码块就加载一次!

  优先级:

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

  三，继承（重点）

  什么时候用继承：不要为了是部分功能而使用继承关系

  1 概念：将多个类的共性内容抽取到一个独立的类中,然后这多个类和独立的这个类产生一种关系: 继承关系! （关键字 extengds）

  格式：class Zi extends Fu{}

  2 好处：

  1)提高代码的维护性!

  2)提高代码的复用性!

  3)让类和类之间产生的关系,是"多态的前提条件"

  开发中 设计原则都要遵循一个原则： "低(松)耦合,高内聚"(重点)

  3 继承(研究的都是类)的特点:

  1)类与类之间的关系,继承关系,只支持单继承

  格式：

  class 子类名 extends 父类名{}

  在有的语言里面,是支持多继承的 (Java中不支持这种写法)

  class 子类名 extends 父类名1,父类名2,..{}

  2)虽然不能支持多继承,但是可以支持多层继承!

  4 注意事项

  • 1)子类继承父类:可以继承父类的非私有的成员,私有的成员外界不能访问的,只能在本类中访问

  • 但是可以通过公共方法间接访问! *

  • 2)构造方法是不能被继承的,但是子类可以间接通过 super关键字访问父类的构造方法(等会讲super)

  5 一个类的组成

  1）成员变量

  2）成员方法

  3）构造方法

  继承中，每个成员变量的关系问题

  • a)子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致,分别访问即可!

  • b)子类继承父类,如果子类的成员变量名称和父类的成员变量名称一致:如何访问呢? (重点)

  • 1)首先在子类的局部位置找,是否存在局部变量名称,如果有,就使用

  • 2)如果没有,就在子类的成员位置找,是否存在这个变量,如果存在,就使用

  • 3)如果在子类的成员位置中没有找到,直接在父类的成员位置中找,如果有,就是使用!

  • 4)如果父类的成员位置都没有,就没有这个变量,报错!

    * 遵循一个原则:就近原则! *

    继承中，构造方法的访问:

    1）子类继承父类,子类的所有的构造方法都会默认的访问父类的无参方法 (super())

    一般: 子类的无参构造方法--访问父类的构造方法

    子类的有参构造方法---访问父类的有参构造方法

    子类的所有构造方法的第一句话:默认隐藏了super() ;  因为子类中肯能会使用到父类的数据,
    ​
    所以在继承关系中得先让父类初始化---->构造方法  : 分层初始化!(先父类无参构造方法,再执行子类的构造方法)
    ​
    •                    super:代表的父类对象的空间表示(父类对象的地址值引用!)
    ​

    2）如果父类中的无参构造方法没有,子类会怎么样?

    如果父类中的无参构造方法没有,子类会怎么样?
     *   子类的所有的构造都会报错! (因为子类所有构造方法默认父类的无参构造方法!)
     *
     *  如何解决呢?
     *      方式1:手动给出父类的无参构造方法(推荐)
     *      方式2:在子类的构造方法中的第一句话:通过super(xxx),间接的访问父类的有参构造方法
     *      方式3:只要子类的所有构造方法中一个能够让父类初始化即可!
     *           在子类的有参构造方法中:this():--->访问本类的无参构造方法,然后再子类的无参构造方法中
     *              间接访问父类的有参构造方法super(xxx) 

    继承中，成员方法的访问：

    a）如果子类和父类的成员方法(公共的方法)名称不一致,那么分别调用即可! b）如果子类和父类的成员方法名称一致,

    先在子类中找是否存在这个方法,如果存在,就使用!

    如果子类中没有,在父类中找,如果存在,就使用!

    如果父类也没有,就报错!(说明没有方法)

    注意

    1继承的初始化问题：分层初始化:先让父类初始化,然后子类初始化

    2代码块的优先级：跟静态相关的先执行:静态代码块先执行,就执行一次!

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

  day2

  一，this与super

  this:代表的当前类对象的地址值引用

  super:代表的父类对象的地址值引用(代表父类的空间标识)

  • 访问成员变量

    this.变量名; 访问的本类中的成员变量

    super.变量名; 访问的是父类的成员变量

  • 访问构造方法:

    this() ; 访问本类的无参构造方法

    super() ;访问的父类的无参构造方法

    this(xxx);访问的本类的有参构造方法

    super(xxx);访问的父类的有参构造方法

  • 成员方法:

    this.方法名();访问的是本类的成员方法

    super.方法名() ;访问的是父类的成员方法

  二，方法重写（override）

  概念：在继承关系中,子类出现了父类一模一样的方法声明

  目的：子类有自己的功能,需要将父类的该功能覆盖掉!

  面试题
  方法重载和方法重写的区别
  ​
  方法重载:在一个类中,提供n多个功能,这些功能,方法名相同,参数列表不同,与返回值无关(目的:提高某个功能的扩展性)
                     参数列表不同:
                                 1)类型不同
                                 2)个数不同
                                 3)考虑参数类型的顺序
  ​
                                  public static void open(int a,double d){}
                                  public static void open(double a,int b){}
                      构造方法也可以重载!

  三，关键字final

  最终的,无法更改的(状态修饰符)

  1，特点：

  1)可以修饰类,该类不能被继承!

  2)可以修饰符成员方法,成员方法不能重写! (例如：不想让父类的方法被子类改写覆盖，父类方法是独立的)

  3)可以修饰的变量,这个变量此时是一个常量! (自定义常量)

  普通变量

  • final int a = 10 ;

    实例变量

  • final Student s = new Student()

  final修饰基本数据类型和引用类型的区别?
   *
   *      final修饰基本数据类型: 基本数据类型的对应的数据值不能在被赋值了,只能赋值一次!
   *      final修饰引用类型:引用数据类型对应的地址值不能被改变
   *             final Student s = new Student() ;//修饰实例变量s,s的堆内存地址值永远是固定值!
   *                           s = new Student() ;//重新开辟空间(报错)

  四，多态

  1，概念：一个事物在不同时态的不同形态,

  2，多态的前提条件:

  • 1)必须存在继承关系 (extends)

  • 2)必须存在方法重写

  • 子类需要覆盖父类的功能

3，成员特点：

• Fu fu = new Zi() ;

• 1)针对成员变量的访问问题:

• 编译看左,运行看左!(使用父亲的东西)

• 2)针对多态中的成员方法的访问问题: 我们所说的成员变量/成员方法----非static

• 编译看左,运行看右(因为子类重写了父类的东西)

• 3)如果成员方法是静态方法:(静态成员方法 算不上方法重写,直接可以类名来访问,跟类相关的方法)

• 编译看左,运行看左

• 4)构造方法:

• 存在继承关系: 还需要让父类先初始化,然后再子类进行数据初始化!(分层初始化!)

3，多态的好处:

• 1)提高代码的复用性:由继承保证

• 2)提高了代码的扩展性:由多态保证 (重点)

  Fu fu = new Zi() ; 父类引用可以指向子类对象

day3

一，多态问题

1,要使用多态:必须得前提条件:

• 1)必须存在继承关系

• 2)必须存在方法重写:

  举例:动物类Animal,Cat类,Dog类，Cat类和Dog类都继承自Animal类

• 3)必须有父类引用指向子类对象: ----也叫"向上转型"

2,多态成员的访问特点:

• Fu f = new Zi() ;

• 成员变量:编译看左(看Fu类是否存在变量,存在,编译不会报错!)

  运行看左(使用Fu类的东西)

• 成员方法:(一般没有明确是静态方法的都是----->非静态)

  编译看左(看Fu类是否存在这个方法,存在,编译不会报错!)

  运行看右(存在方法重写,所以最终子类的功能将父类的该功能进行覆盖!)

• 静态的方法:

  编译看左看Fu类是否存在这个静态方法,存在,编译不会报错!),

  运行看左(静态方法:子类出现了父类一模一样的静态方法,算不上重写,跟类相关的---->类成员)

  静态功能推荐的方式:类名.访问

• 构造方法:

  即使多态的情况进行测试,多态的前提条件---->继承关系

  当前执行子类的构造方法之前,需要让父类的先进行初始化,然后子类进行初始化(分层初始化!)

3,多态的弊端:

不能访问子类的特有功能 (Fu f = new Zi())

f.方法名() ；报错了. 父类中没有子类特有功能!

解决方法1（不推荐）

本身Fu f = new Zi() ;已经在堆内存中开辟空间了

Zi z = new Zi() ;在堆内存中又开辟空间,从内存角度考虑,这种比较消耗内存空间,不太好!

解决方法2（推荐使用:"向下转型"）

多态的第三个前提条件:父类 引用指向子类对象 :"向上转型 "Fu f = new Zi() ;

将父类的引用转换成子类的引用；（好处:不需要在堆内存开辟空间）

“向下转型” -----> Zi z = (Zi)f ; 还原成子类型

强转类型转换: 目标类型 变量名 =(目标类型)初始化值

4多态的方式:

使用向下转型时,可能出现异常?

要使用向下转型,前提必须有父类引用指向子类对象 Fu f = new Zi() ;

遵循向下转型的格式:

Zi z = (Zi)f; 必须心里清楚堆内存存储的类型....

向下转型使用不当,就出现java.lang.ClassCastException:类转换异常: (属于运行时期异常)

当前堆内存中的实例不是该类型时,就会出现问题!