Java 面向对象学习笔记

Day01笔记:
1.什么是类？什么是对象？
  1)现实世界是由很多很多对象组成的
    基于对象抽出了类
  2)对象:真实存在的单个的个体
    类:类型/类别，代表一类个体
  3)类中可以包含:
    3.1)所有对象所共有的属性/特征-------成员变量
3.2)所有对象所共有的行为------------方法
  4)一个类可以包含多个对象
    同一类型的多个对象，结构相同，数据不同
  5)类是对象的模板，对象是类的具体的实例
2.如何创建类？如何创建对象？如何访问成员？
3.引用类型之间画等号:
  1)指向同一个对象
  2)对一个引用的修改会影响另一个引用
    eg:房子钥匙
  基本类型之间画等号:
  1)赋值
  2)对一个变量的修改不会影响另一个变量
    eg:身份证复印件
4.null:空，没有指向任何对象
       若引用的值为null，则该引用不能再进行任何操作了
  若操作则NullPointerException空指针异常




Day02笔记:
0.方法的签名:方法名+参数列表
1.方法的重载(Overload):
  1)发生在一个类中，方法名称相同，参数列表不同
  2)编译器在编译时自动根据方法的签名绑定调用的方法
2.构造方法:
  1)常常用于给成员变量赋初值
  2)与类同名，没有返回值类型
  3)在创建(new)对象时被自动调用
  4)若自己不写构造，则编译器默认一个无参构造
    若自己写了构造，则不再默认提供
  5)构造方法可以重载
3.this:指代当前对象，哪个对象调方法指的就是哪个对象
       只能用在方法中，方法中访问成员变量之前默认有个this.
  this的用法:
  1)this.成员变量名-------访问成员变量
  2)this.方法名()---------调用方法
  3)this()----------------调用构造方法
4.引用类型数组:
  1)Cell[] cells = new Cell[4];
    cells[0] = new Cell(2,5);
cells[1] = new Cell(2,6);
cells[2] = new Cell(2,7);
cells[3] = new Cell(3,6);
  2)Cell[] cells = new Cell[]{
      new Cell(2,5),
 new Cell(2,6),
 new Cell(2,7),
 new Cell(3,6)
    };
  3)int[][] arr = new int[3][];
    arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
arr[1][0] = 100; //给arr中第2个元素中的第1个元素赋值为100
  4)int[][] arr = new int[3][4]; //3行4列
    for(int i=0;i<arr.length;i++){
 for(int j=0;j<arr[i].length;j++){
   arr[i][j] = 100;
 }
}


Day03 笔记:
1.内存管理:由JVM来管理---------了解
  1)堆:
    1.1)存储所有new出来的对象(包括成员变量)
1.2)垃圾:没有任何引用指向的对象
   垃圾回收器(GC)不定时去堆中回收垃圾，
回收过程是透明的，并不一定是发现垃圾就立即回收
通过调用System.gc()可以建议虚拟机尽快调度GC来回收
1.3)内存泄漏:不再使用的内存还没有被及时的回收
   建议:对象不再使用时，及时将引用设置为null
1.4)成员变量的生命周期:
     创建对象时存在堆中，对象被回收时一并被回收
  2)栈:
    2.1)存储正在调用的方法中的所有局部变量(包括参数)
2.2)调用方法时会在栈中为该方法分配一块对应的栈帧，
   栈帧中包含方法中的所有的局部变量(包括参数)，
方法执行完，则栈帧被清除，局部变量一并失效
2.3)局部变量的生命周期:
     调用方法时存在栈中，方法执行结束后与栈帧一并被清除
  3)方法区:
    3.1)存储.class字节码文件(包括方法)
3.2)方法只有一份，通过this来区分具体的调用对象
2.继承:
  1)作用:实现代码的复用
  2)通过extends来实现继承
  3)父类:所有子类所共有的属性和行为
    子类:子类所特有的属性和行为
  4)子继承父后，子类具有:父+子
  5)一个父类可以多个子类，
    一个子类只能继承一个父类----单一继承
  6)继承具有传递性
  7)java规定:构造子类之前必须先构造父类
    子类构造中若没有调用父类的构造，则默认super()调父类的无参构造
若子类构造中调用了父类的构造，则不再默认提供
super()调父类构造必须位于子类构造的第一句
3.super:指代当前对象的父类对象
  super的用法:
    1)super.成员变量名------访问父类的成员变量
2)super.方法名()--------调用父类的方法
3)super()---------------调用父类的构造方法
4.向上造型:（需要理解）
  1)父类型的引用指向子类的对象
  2)能点出来什么，看引用的类型


Day04笔记:
1.方法的重写(Override):重新写、覆盖
  1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
  2)重写方法被调用时，看对象的类型
2.重写与重载的区别:----常见面试题
  1)重写(Override):
    1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
1.2)遵循"运行期"绑定，看对象的类型调用方法
  2)重载(Overload):
    2.1)发生在同一类中，方法名称相同，参数列表不同，方法体不同
2.2)遵循"编译期"绑定，看引用的类型绑定方法
3.package:
  1)作用:避免类的命名冲突
  2)包名可以有层次结构，类的全称: 包名.类名
  3)同包中的类不能同名
  4)建议:包名所有字母都小写
  import:
  1)同包中的类可以直接访问
    不同包中的类不能直接访问，若想访问:
1.1)先import后再访问------建议
1.2)类的全称--------------太繁琐，不建议
4.访问控制修饰符:
  1)public:公共的，任何类
  2)private:私有的，本类
  3)protected:受保护的，本类、子类、同包类
  4)默认的:什么也不写，本类、同包类
  类的访问控制修饰符只能是public或默认的
  类中的成员如上4种都可以
5.static:静态的
  1)静态变量:
    1.1)由static修饰的
1.2)属于类的，存在方法区中，只有一份
1.3)常常通过类名点来访问
1.4)何时用:所有对象所共享的数据(图片、音频、视频等)
  2)静态方法:
    2.1)由static修饰的
2.2)属于类的，存在方法区中，只有一份
2.3)常常通过类名点来访问
2.4)静态方法没有隐式的this传递，
   静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
  3)静态块:
    3.1)属于类的，在类被加载期间自动执行，
   因为类只被加载一次，所以静态块也只执行一次
3.2)何时用:初始化/加载静态资源(图片、音频、视频等)


Day05笔记:
1.final:最终的、不可变的
  1)修饰变量:变量不能被改变
  2)修饰方法:方法不能被重写
  3)修饰类:类不能被继承
final 修饰成员变量，只有两种初始化方式：
1.声明的同时初始化
2.在构造方法中初始化
final修饰局部变量：只要用在初始化之前即可
2.static final:常量
  1)必须声明同时初始化
  2)通过类名来访问，不能被改变
  3)常量名所有字母都大写，多个单词用_分隔
  4)编译器在编译时会将常量直接替换为具体的值，效率高
3.抽象方法:
  1)由abstract修饰
  2)只有方法的定义，没有方法的具体实现(连{}都没有)
4.抽象类:
  1)由abstract修饰
  2)包含抽象方法的类必须是抽象类
    不包含抽象方法的类也可以声明为抽象类---我乐意
  3)抽象类不能被实例化
  4)抽象类是需要被继承的，子类:
    4.1)重写抽象类的所有抽象方法----常用
4.2)也声明为抽象类--------------不常用
  5)抽象类的意义:
    5.1)封装子类所共有的属性和行为-----代码复用
5.2)为所有子类提供一种统一的类型---向上造型
5.3)可以包含抽象方法，为所有子类提供了统一的入口，
   子类的实现不同，但入口是一致的
5.接口:
  1)是一个标准、规范------制定方
    遵守了这个标准，就能干某件事-----API之后
  2)是一种数据类型(引用类型)
  3)由interface定义，
    只能包含常量和抽象方法
  4)接口不能被实例化
  5)接口是需要被实现的，实现类:
      必须重写接口中的所有抽象方法
  6)一个类可以实现多个接口
    若又继承又实现时，必须先继承后实现
  7)接口可以继承接口


Day06笔记:
1.多态:
  1)意义:
    1.1)同一类型的引用指向不同的对象时，有不同的实现
   ------行为的多态: cut()、run()、teach()
1.2)同一个对象被造型为不同的类型时，有不同的功能
   ------对象的多态: 我、你、水...
  2)向上造型:
    2.1)父类型的引用指向子类的对象
2.2)能造型成为的类型有: 父类、所实现的接口 
2.3)能点出来什么，看引用的类型
  3)强制类型转换，成功的条件有两种:
    3.1)引用所指向的对象，就是该类型
3.2)引用所指向的对象，实现了该接口
  4)若不满足如上两个条件，则发生ClassCastException类型转换异常
    建议:在强转之前先通过instanceof判断引用指向的对象是否是该类型
2.成员内部类: 应用几率不大
  1)类中套类，里面的称为Inner，外面的称为Outer
  2)内部类通常只服务于外部类，对外不具备可见性
  3)内部类对象通常是在外部类中创建的
  4)内部类中可以直接访问外部类的成员，包括私有的
    内部类中有个隐式的引用指向了创建它的外部类对象
 外部类名.this.
3.匿名内部类:
  1)若想创建一个类(子类)的对象，并且对象只被创建一个，
    此时该类不必命名，称之为匿名内部类
  2)匿名内部类中访问外部的变量，该变量必须是final的




面向对象三大特征:
1.封装:
  1)类:封装的是对象的属性和行为
  2)方法:封装的是业务逻辑功能的实现
  3)访问控制修饰符:封装的是访问的权限
2.继承:
  1)作用:代码复用
    通过extends来实现继承
  2)父类/基类:共有的  
    子类/派生类:特有的
  3)单一继承、多接口实现
3.多态:
  1)意义:行为的多态、对象的多态
  2)向上造型、强制类型转换、instanceof
  3)多态的表现形式:
    3.1)重写
3.2)重载