JAVA零基础学习课程个人笔记（全手打）

目录

chapter01

Chapter02 目录

Chapter02   Day05~07-方法-Method-课堂笔记

chapter02_控制循环中断继续语句

chapter03.0_面向对象

chapter03.1_封装

chapter03.2_构造方法

chapter03.3_对象和引用

chapter03.4_参数传递

chapter03.5_this关键字

chapter03.6_static静态变量

chapter03.7_类的继承、重载、覆盖

---

写在前面：代码之前都写在本地了没有上传完整，有人需要的话私信我再传。后面的内容会新开博文继续更新。

chapter01

*    java中如何书写注释？
    1.单行注释：//
    2.多行注释：/*55481315
                55换房哈弗里看见的减肥*/
    3.javadoc注释：
    /**
    *javadoc注释
    *这种注释将会被解析成帮助文档，单独生成
    *这种注释将会被解析成帮助文档，单独生成
    *这种注释将会被解析成帮助文档，单独生成
    */

*    public class 和 Class 的区别
    # 一个java源文件当中可以定义多个class
    # 一个java源文件当中 public 的 class 不是必须的，可以没有
    # 一个 class 会定义生成一个 xxx.class 字节码文件 
    # 一个java源文件当中定义公开类 public 的 class 只能有一个，且该类名必须和 .java 源文件名称一致
        否则编译阶段将报错：
        A.java:1: 错误: 类C是公共的, 应在名为 C.java 的文件中声明
        public class C{
                  ^
        1 个错误
    # 每一个class中都可编写main方法，都可以设定程序入口，想执行 A.class中的 main 方法，编译后执行 java A 命令即可。
    # 注意：当在命令窗口中执行 java B，那么要求 B.class 中必须有主方法，没有主方法将会出现运行阶段的错误：
        “错误: 在类 B 中找不到 main 方法, 请将 main 方法定义为:
               public static void main(String[] args)
        否则 JavaFX 应用程序类必须扩展javafx.application.Application

*    编译 .java 文件命令：        javac JavaFilename.java 
    运行编译得到的 .class文件命令：    java className
    若报错：  则修改编译语句为：javac -encoding UTF-8 JavaFilename.java 

//cmd中输入native2ascii回车，然后输入中文文字回车，即可得到中文文字对应的unicode编码

Chapter02 目录

标识符
关键字
字面值
变量
数据类型
二进制
字符编码
运算符
控制语句
方法
递归

*    基本数据类型（8种）：
        取值范围：
            类型描述    数据类型    字节数    默认值    取值范围
            字节型    byte     1        0        -2^7~2^7-1        -128 ~ 127
            短整型    short     2        0        -2^15~2^15-1    -32768 ~ 32767
            整型        int     4        0        -2^31~2^31-1    -2147483648 ~ 2147483647
            长整型    long     8        0        -2^63~2^63-1    -‭9,223,372,036,854,775,808‬ ~‭ 9,223,372,036,854,775,8087
            单精度
            浮点型    float     4        0.0                        3.402823e+38 ~ 1.401298e-45
            双精度
            浮点型    double     8        0.0                        1.797693e+308 ~ 4.9000000e-324
            字符型    char     2        \u0000    0~2^16-1        0 ~ 65535
            布尔型    boolean 1        false    true/false
            引用数据类型（String）    null
            short 和 char 表示的种类总数是一样的，只不过char可以表示更大的正整数，因为char没有负数
            局部变量必须先声明再赋值才能编译通过且运行成功，成员变量声明之后没有手动赋值也可以编译运行，系统将会默认赋值。例子：见DataTypeTest02.java
*    字符编码：人类定制的人类使用语言————“文字”和计算机还用的语言————“二进制”之间的对照表/字典
    (1)常用ASCII码：
        'a' --> 97 【01100001】
        'A' --> 65
        '0' --> 48
    (2)国标码（国际标准组织制定的编码，只支持西欧文字）————IOS 8859-1（latin-1）
    (3)支持简体中文的编码方式：GB2312 < GBK < GB18030 (字库容量)；
    (4)支持繁体中文的编码方式：big5（大五码）
    (5)后来出现的一种编码方式统一全球所有文字，容量大————Unicode编码(java采用的编码方式)
        unicode编码多种实现方式：
            UTF-8
            UTF-16
            UTF-32
        java采用的编码方式是unicode编码，所以标识符可以用中文。
        eg：
            class 学生
        现在实际开发中，一般采用 UTF-8 编码较多。
*    总结第二章到目前为止所学内容
        1 标识符
        2 关键字
        3 字面值
        4 变量
        5 数据类型

*    运算符
    - 算术运算符
    - 关系运算符
    - 逻辑运算符
    - 字符串连接运算符
    - 三元运算符

    Day04-课堂笔记
一、运算符【剩下的运算符】
    1、赋值运算符
    2、字符串连接运算符
    3、三目运算符/三元运算符/条件运算符
    
    1、java中的赋值运算符：
        1.1 种类
            1）基本的赋值运算符  = 
            2）扩展的赋值运算符  +=  -=  *=   /=  %= 
        1.2 特点：先执行等号右边的表达式，再将执行结果赋值给左边的变量
        1.3 扩展类的赋值运算符不改变变量类型
            eg：注意以下代码：
            byte i = 10;
            i += 5;  等同于： i = (byte)(i + 5);

            int k = 10;
            k += 5;  等同于： k = (int)(k + 5);

            long x = 10L;
            int y = 20;
            y += x;  等同于： y = (int)(y + x);

    2、字符串连接运算符：关于java中的“+”运算符：
        2.1、+ 运算符在java语言中的两个作用：
            * 加法运算，求和
            * 字符串的连接运算
        2.2、当“+”两边都是数字：一定做加法运算
        2.3、当“+”两天只要存在字符串：一定进行字符串连接运算，且连接运算后的结果仍为字符串类型
            数字 + 数字 ——> 数字 【求和】
            数字 + “字符串” ——> “字符串” 【字符串连接】
        2.4、一个表达式中可出现多个“+”，无括号时自左向右依次运算

    3、三元运算符/三目运算符/条件运算符
        3.1 语法规则： 布尔表达式 ? 表达式1 : 表达式2
        3.2 三元运算符的执行原理：布尔表达式结果为true，选择表达式1为布尔表达式的执行结果；false则选择表达式2为执行结果
            boolean sex = false;
            char c = sex ? '男' : '女';
            String s = sex ? "男生" : "女生";

*    控制语句
    java控制语句7种：
        控制选择结构语句：if、if else、switch
        控制循环结构语句：for、while、do while
        改变控制语句顺序：break、continue
    
*    向控制台输出（从内存到控制台）    System.out.println();    
    接收键盘输入（从键盘到内存）    代码如下：
    第一步：java.util.Scanner s = new java.util.Scanner(System.in);
    第二步：String str = s.next();    或    int num = s.nextInt();
    具体示例可见：KeyInputTest.java文件

//cmd中输入native2ascii回车，然后输入中文文字回车，即可得到中文文字对应的unicode编码

Chapter02   Day05~07-方法-Method-课堂笔记

一、方法 - Method
1、方法的本质:一段代码片段,可完成某个特定的功能,能被重复使用.
2、方法在C语言中被称作函数Function
3、方法定义在类体中,一个类当中可定义多个方法,方法编写位置无先后顺序,随意
4、方法的语法结构:
    {修饰符列表} 返回值类型 方法名(形式参数列表){
        方法体;
    }
5、对以上的语法结构进行解释说明
* 关于修饰符列表:
    1) 可选项，非必须
    2) 目前统一写成: public static [以后讲]
    3) 方法的修饰符列表当中"有static关键字"的话，调用方法？ 
        类名.方法名（实际参列表）;
* 返回值类型:
    1) 定义:一个方法是可以完成某个特定功能的，这个功能结束之后大多数都是需要返回最终执行结果的
    2) 返回值类型:返回值是一个具体存在的效据，数据都是有类型的，此处需要指定的是返回值的具体类型
    3) 可指定类型:Java任意一种类型都可以，包括基本数据类型和所有的引用数据类型(byte,short,long,int,boolean,float,double,char,String,void)
    4) 方法也可以不返回任何数据,返回值类型必须写:void,则方法体不可出现 return 值; 语句,可写 return; 语句
    5) 返回值类型不是void,表示方法执行结束必须返回具体数值,否则编译器将报错,使用 return 数值; 语句返回值
    6) 返回值类型必须和return后数值类型一致,否则编译器报错
    7) 只要带有return关键字的语句执行,其所在方法结束。注:不是JVM结束，是return所在方法结束
* 方法名:
    1) 只要是合法的标识符就行
    2) 方法名最好见名知意
    3) 方法名最好是动词
    4) 方法名首字母要求小写，后面每个单词首字母大写(驼峰命名)
* 形式参数列表(形参):
    1) 形参是局部变量:int a; double b; float c; string s;
    2) 形参的个数可以是:0-N个
    3) 多个形参之间用逗号隔开
    4) 形参中起决定性作用的是形参的数据类型，形参的名字就是局部变量的名字
    5) 方法在调用的时候，实际给这个方法传递的真实数据被称为:实际参数(实参)
    6) 实参列表和形参列表必须满足: 数量相同、类型对应相同
    eg:
        方法定义
        public static int sum(int 变量名,int 合法的标识符就行){
        }
        方法调用
        sum("abc","def")    //编译器报错
        sum(10,20)
* 方法体必须由大括号括起来，方法体当中的代码有顺序，自上而下依次执行,方法体中每一个java语句以;“结尾.
6、方法调用：
    方法的修饰符列表当中有static关键字，完整的调用方式：类名.方法名(实参列表)
    但有时"类名."可以省略,什么情况下可省?——同类可省:调用程序和被调用方法在同一个类中,则"类名."可省略不写
    省略"类名."会默认从当前类中找方法。
    建议在一个java源文件中只定义一个class，比较清晰，这里只是为了讲课方便而编写多个class，请勿模仿！
7、方法在执行过程当中,在JVM中的内存是如何分配,如何变化的?
    1)方法只定义,不调用,是不会执行的,在JVM中也不会给该方法分配"运行所属"的内存空间,调用时才会分配内存空间
    2)在JVM内存划分上有这三块主要内存空间:
        * 方法区内存
        * 堆内存
        * 栈内存
    3)关于栈数据结构:
        * 栈:stack,一种数据结构(反映的是数据的存储形态)
        * 作为程序员需要提前精通:数据结构 + 算法
        * 常见的数据结构:数组、队列、栈、链表、二叉树、哈希表、散列表
        * java程序员可在不精通数据结构和算法的前提下进行java开发,因为java有一套庞大的类库支撑
    4)方法代码片段存在哪里?方法执行时候,执行过程的内存在哪里分配?
        * 方法代码片段属于 .class 字节码文件的一部分,字节码文件在类加载的时候,将其放到了方法区中.
          所以JVM中三块内存空间中方法区内存最先有数据,存放了代码片段(小说书本文字)
        * 代码片段虽然在方法区当中只有一份,但是可以被重复调用
          每一次调用此方法都需要给该方法分配独立活动场所,在栈内存中分配(小说情节实际发生地点)
          栈内存中分配方法运行的所属内存空间
    5)方法在调用瞬间,会给该方法分配内存空间,会在栈中发生压栈动作 push;(给方法分配内存)
      方法结束之后,给该方法分配的内存空间全部释放,此时发生弹栈动作 pop.(释放该方法的内存空间)
    6)局部变量在"方法体"中声明,运行阶段内存在栈中分配.
8、Day07 - 课堂笔记
*    方法执行过程中的内存分配
    1)在EditPlus当中,红色字体表示一个类的名字,且此类为JAVASE中自带的 
      D:\Java\jdk1.8.0_121\jre\lib\rt.jar\java\lang中  
      例如:System.class/String.class/Math.class......
      只要是类名就一定是标识符
    2)重点:方法调用时,只要涉及到参数传递的问题,实际上是变量中保存的那个"值"传过去了
    3)方法执行时遵循自上而下的顺序依次执行
*    方法的重载机制
    优点:
    1)程序员调用方法方便,随调用不同方法,但感觉在调用同一方法,无序记忆更多方法名
    2)功能相似时方法名不同,功能不同方法名不要相同,不要重载
    重载:
    1)方法重载又称为:overload
    2)合适考虑使用方法重载?
        * 功能相似时,尽可能让方法名相同; 但功能不相似时,尽可能让方法名不同
    3)什么条件满足之后构成了方法重载?
        * 在同一类中
        * 方法名相同
        * 参数列表不同:   数量不同/顺序不同/类型不同
    4)方法重载和什么有关,和什么无关?
        * 和参数列表类型有关,和返回值类型无关
        * 和修饰符列表无关
*    方法的递归调用
    1)什么是递归?    ----方法自身调用自身
        a(){
            a();
        }
    2)递归很耗费内存,可不使用时尽量不要用
    3)递归永不结束时候程序报错:java.lang.StackOverflowError
    栈内存溢出错误
    错误发生无法挽回,只有JVM停止工作一个结果.
    4)故递归必须有结束条件,若无则会发生栈内存溢出错误
    5)递归即使有结束条件且结束条件正确,也可能会发生栈内存溢出错误

chapter02_控制循环中断继续语句

Day05-课堂笔记
一、控制语句 - switch
    1、switch 语句属于选择结构、也是分支语句
    2、switch 语句语法结构（jdk6只支持int，7开始支持String）
        switch(int 或 String 类型的变量/字面值){
            case int 或 String 类型的变量/字面值：
                java语句;
                .....
                break;
            case int 或 String 类型的变量/字面值：
                java语句;
                .....
                break;
            case int 或 String 类型的变量/字面值：
                java语句;
                .....
                break;
            ......
            default :
                java语句;
                ......
        }
    3、switch 语句执行原理：
        switch小括号当中的数据和case后面的“数据”进行一一匹配，匹配成功的分支执行，自上而下依次匹配。
    4、匹配成功的分支执行，分支中有 break; 时，整个 switch 语句中止。
    5、匹配成功的分支执行，但当分支中无 break; 时，则下面的语句不进行匹配，直接执行下一分支；
        这是【case 穿透现象】。
    6、所有分支都没有匹配成功，当有 default 语句时，执行 default 分支中语句。
    7、switch 后面和 case 后面只能是 int 或 String 类型的变量/字面值，不能探测其他类型
        当然 byte、short、char 也可以直接写到 switch 和 case 后面，因可进行自动类型转换成int
        JDK6的 switch 和 case 后面只能探测 int 类型
        JDK7之后包括7版本在内，引入新特性，switch 和 case 后面可探测 int 或 String 类型数据
    8、case 可以合并：
        int i = 10;
        switch(i){
            case 1: case 2: case 3: case 10:
                System.out.println("Test Code!");
        }
二、控制语句 - for
    1、语法结构:
        for(初始化语句1; 布尔判断语句2; 更新语句4){
            java语句3
        }
    其中：for后面三个语句都不是必需的，但是两个两个分号却是，故分号不能丢。
    2、执行顺序：1 2 3 4 2 3 4 2 3 4 2 3 4 2 ……/1 2
三、循环语句 - while
    1、语法结构:
        while(布尔表达式1){
            循环体2;
        }
    (布尔表达式1为true则执行循环体2,为false则循环结束)
    2、执行顺序:    1/1 2 1 2 1 2 1 2 1 2 1 2 ......1
    3、循环体执行次数: 0次 ~ N次
四、循环语句 - do...while
    1、语法结构:
        do{
            循环体1;
        }while(布尔表达式2);
    (布尔表达式2为true则执行循环体1,为false则循环结束)
    2、执行次数: 1次 ~ N次
    3、执行顺序: 1 2/1 2 1 2 1 2 1 2 1 2 1 2 ......2
五、中断/终止语句 - break
    1、break; / break 循环名称;
    2、使用环境:
        1)switch 语句中,终止该语句的执行
        2)循环语句(for,while,do...while)当中,用来跳出/终止循环的执行,可提高程序执行效率
六、继续语句 - continue
    1、continue; / continue 循环名称;
    2、含义:继续/go on/下一个
    3、break 和 continue 的区别：
        break 表示循环不执行了，跳出循环，终止循环
        continue 表示终止当前“本次”循环，直接进入下一次循环继续执行

chapter03.0_面向对象

Chapter03  面向对象 Java语言的核心机制
    面向过程和面向对象的区别
    面向对象的三大特征
    类和对象的概念
    类的定义【从这里开始编写代码】

一、采用面向对象的方式开发一个软件，生命周期包含：
    1、面向对象的分析：OOA
    2、面向对象的设计：OOD
    3、面向对象的编程：OOP
    整个生命周期中贯穿着面向对象方式OO
二、 面向对象的三大特征
    1、封装
    2、继承
    3、多态
三、类的概念
    类不存在于现实世界，是一个模板、概念，是人类大脑思考抽象的结果。
    类代表一类食事物
    在现实世界中，对象A和对象B之间具有共同特征，进行抽象总结出一个模板，此模板即为类
    一个类主要描述 状态 + 动作
    状态 --> 一个类的属性
    动作 --> 一个类的方法
    类{
        属性；//描述对象的状态信息
        方法；//描述对象的动作信息
    }
四、对象的概念
    对象是实际存在的个体，现实世界中实际存在
    对象和对象之间有共同的特征，但是具体到对象之后可能有数据的差异
五、类的定义【从这里开始编写代码】
    语法结构：
    [修饰符列表] class 类名{

    }
    1、属性通常采用成员变量的方式来定义
    2、方法描述的是对象的动作信息
六、Java语言当中包括的两种数据类型
    1、基本的数据类型：byte、short、int、long、float、double、boolean、char
    2、引用数据类型：String、System（SUN提供的）、User、Product、Student、Customer（程序员自定义的）
    Java中的class都属于引用数据类型
七、对象的创建和使用
    1、创建（实例化对象）语法： new 类名();
    2、new运算符作用：创建对象，在JVM堆内存中开辟新内存空间
    3、方法区内存：类加载时class字节码片段被加载到该内存空间中
        栈内存（局部变量）：方法代码片段执行时，会给该方法分配内存空间，在栈内存中压栈
        堆内存：new 的对象在堆内存中存储
    4、局部变量：存储位置：栈内存、书写位置：类体的方法内
      成员变量：存储位置：不确定、书写位置：类体中方法体外
      成员变量 中的 实例变量：在 堆内存 的java对象内部存储
      实例变量是一个对象一份，100个对象有100份
    5、对象和引用的区别联系：
        对象：new 运算符在堆内存中开辟的内存空间称为对象；
        引用：引用是一个变量，只不过这个变量中保存了另一个Java对象的内存地址
    6、关于引用：
        Java语言中，程序员不能直接操作堆内存，Java没有指针，不像C语言；
        Java语言中，程序员只能通过“引用”去访问堆内存当中对象内部的实例变量
    7、访问实例变量的语法格式：
        读取数据：引用.变量名;
        修改数据：引用.变量名 = 值;
八、Java虚拟机主要包括三块内存空间：方法区内存、堆内存、栈内存
    1、堆内存和方法区内存各有一个；栈内存一个线程对应一个栈内存；
    2、方法调用时，该方法所需内存空间在栈内存中分配，称为压栈，方法执行结束后，该方法所属内存空间释放，称为弹栈
    3、栈中主要存储的是方法体中的局部变量
    4、方法的代码片段以及整个类的代码片段都被存储到方法区内存当中，在类加载时，这些代码片段会载入
    5、在程序执行过程中，使用new运算符创建的Java对象，存储在堆内存当中，对象内部有实例变量，所以实例变量存储在堆内存当中
    6、变量分类：
        局部变量【方法体中声明】：存储在栈内存
        成员变量【方法体外类体中声明】
            1）实例变量【前面修饰符无static】：存储在堆内存
            2）静态变量【前面修饰符有static】：存储在方法区内存中
    7、三块内存中：
        变化最频繁的：栈内存
        最先有数据的：方法区内存
        垃圾回收器主要针对的：堆内存
    8、垃圾回收器【自动回收机制/GC机制】何时会考虑将某个Java对象的内存回收呢？
        没有更多的引用指向堆内存中的Java对象时，此对象无法被访问（因为访问对象只能通过引用方式），故此对象会被回收。
九、空指针报错
    空引用访问"实例"相关的数据一定会出现空指针异常 java.lang.NullPointerException
    如以下程序：
        Customer c = new Customer();
        System.out.println(c.id);    //0
        c = null;
        System.out.println(c.id);    //运行报错空指针

chapter03.1_封装

封装
一、好处：
    1、封装后，对于那个事物来说，看不到复杂一面，只看到简单一面
    复杂性封装对外提供简单的操作入口。如：照相机/电视机内部实现原理复杂，操作使用却非常方便快捷。
    2、封装后才会形成真正的“独立体”，真正的“对象”。
    3、封装就意味着以后的程序可以重复使用，且适用性强，可在任意场合适用。
    4、提高安全性，安全级别高。
二、步骤：
    1、所有属性私有化，使用 private 关键字修饰，修饰的数据只能在本类中访问
    2、对外提供简单的操作入口，外部程序想要访问私有属性必须通过这些简单入口
        - 对外提供两个公开的方法，分别是set方法（修改属性）和get方法（读取属性）
        - 一般都要在set方法中加安全控制，因为要修改数据
    3、set方法的命名规范：public void set+属性名首字母大写(参数)
        public void setAge(int a){
            age = a;
        }
    4、get方法的命名规范：public void set+属性名首字母大写()
        public int getAge(){
            return age;
        }
    5、背诵内容：
        1）setter and getter 方法没有static关键字
        2）有static关键字修饰的方法怎么调用：类名.方法名(实参);
        3）无static关键字修饰的方法怎么调用：引用.方法名(实参);

chapter03.2_构造方法

构造方法：
    1、构造方法又被称为构造函数/构造器/Constructor
    2、语法结构：
        [修饰符列表] 构造方法名(形式参数列表){
            构造方法体;
        }
    3、回顾普通方法的语法结构:
        [修饰符列表] 返回值类型 方法名(形式参数列表){
            方法体;
        }
    4、对于构造函数来说,"返回值类型"不需要指定,并且也不能写void(写了就是普通方法)
    5、构造方法的方法名必须和类名保持一致
    6、构造方法的作用: 1)通过构造方法的调用,可以创建对象 2)创建对象的同时,初始化实例变量的内存空间
    7、普通方法调用:方法修饰符中有static时:类名.方法名(实参列表)、无static时:引用.方法名
      构造方法调用: new 构造方法名(实参列表)
    8、每个构造方法执行结束都有返回值,但这个return语句不用写,返回值类型是构造方法所在类的类型
    9、当一个类中没有构造任何方法,系统默认给该类提供一无参的构造方法,为缺省构造器
    10、当一个类由用户将构造方法定义出来了,那么系统将不再提供缺省构造器,建议开发中手动为当前类提供无参数构造方法
    11、构造方法显示可以重载,在一个类中编写多个不同参数列表的构造方法,这些构造方法可以重载

chapter03.3_对象和引用

对象和引用：
    1、对象：目前在使用new运算符在堆内存中开辟的内存空间称为对象
    2、引用：保存了内存地址，指向堆内存中的对象。
    3、引用是一个变量，不一定是局部变量，还可能是成员变量（husband类中有Wife类的变量w）
    4、所有访问实例相关的数据，都需要通过“引用.”的方式访问，因为只有通过引用才能找到对象
    5、只有一个空的引用 访问对象的实例相关的数据会出现空指针异常
        class Student{
            Computer com;    //com是一个引用【实例变量】

            public static void doSome(){
                Computer c;    //c是一个引用【局部变量】
            }
        }

chapter03.4_参数传递

Java语言中方法调用时涉及到的参数传递问题：
    参数传递实际上传递的是变量中保存的具体值，而不是变量本身！
    eg：
    int i = 5;
    int j = i;    //i传递给j,实际上只是把i变量中的5传给j了,j实际上是一块全新的内存空间

    User u1 = new User();    //假设 u1 = 0x1234
    u1.name = "Lily";
    User u2 = u1;    //u1传递给u2,实际上是将0x1234这个对象的地址值赋给u2了.
    u2.name = "Clara";
    //u1和u2实际是两个不同的局部变量,但此时这两个变量指向堆内存中同一个java对象
    System.out.println(u1.name);    //结果为Clara

chapter03.5_this关键字

Day10：this关键字
1、this是一个关键字，翻译为：这个
2、this是一个引用、一个变量，this变量汇总保存了内存地址指向自身，this存储在JVM堆内存Java对象内部
3、创建100个Java对象，每个对象都有this（100个不同的this）
4、this可以出现在“实例方法”中，指向当前正在执行这个动作的对象
5、this在多数情况下都是可以省略不写的
6、this不能使用在带有static的方法当中
    1）带有static的方法中不能“直接”访问实例变量和实例方法，因为它们都需要对象的存在
    2）而static的方法当中当前对象不存在，也就是没有this，自然也就无法访问当前对象的实例变量和实例方法
7、this可以用在哪里：
    1）可以使用在实例方法中，代表当前对象【语法格式：this.】
    2）可以使用在构造方法中，通过当前的调用方法调用其他的构造方法【语法格式：this(实参)】
    重点【记忆】：this()这种语法只能出现在构造函数的第一行
    eg：
    public Customer(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public Customer(){
        this("初始化姓名",-1);  
    }
8、实例相关的数据包括：
    实例变量【对象需要存在】
    实例方法【对象需要存在】
9、带有static的方法,其实既可以采用类名的方式访问,也可以采用引用.的方式访问；
    但是即使采用引用的方式去访问,实际上执行的时候和引用指向的对象也无关；
    带有static的方式还是建议使用"类名."的方式访问；
    所以计算使用空引用访问带有static的方法，也不会产生空指针异常的报错。
    Test t = new Test();
    //引用是空
    t = null;
    t.doSome();    //这里不会报错空指针异常

chapter03.6_static静态变量

Day10：static静态变量
1、static：静态的
    static修饰的变量：静态变量
    static修饰的方法：静态方法
    所有static修饰的元素都是静态的，都可以使用“类名.”（推荐）和“引用.”的方式访问
    所有static修饰的元素都是类级别的特征，和对象无关。
2、静态变量：
  对所有对象一个属性都一样,属性值相同，这种特征属于类级别的特征,可以提升为整个模板的特征,变量前加static关键字修饰
  静态变量在类加载的时候初始化,不需要创建对象,内存就开辟了。（实例变量在构造方法执行的时候初始化）
  静态变量存储在方法区内存中。
（局部变量存储在栈内存中，
  实例变量存储在堆内存的java对象内部）
3、静态代码块
    可以使用static关键字定义静态代码块
    1）语法格式：
        static{
            java语句;
        }
    2）静态代码块在类加载时执行，并且只执行一次
    3）静态代码块在一个类中可以编写多个，并且遵循自上而下的顺序依次执行
    4）静态代码快的作用？怎么用？用在哪儿？什么时候用？
        和具体需求有关，如项目中要求在类加载的时刻/时机，执行代码，完整日志的记录，那么这段记录日志的代码就可以编写到静态代码块中。
        静态代码快是java为程序员准备的一个特殊的时刻——类加载时刻，若希望在此刻执行一段特殊的程序，这段程序可以直接放到静态代码块当中。
4、实例代码块/语句块(了解内容即可,使用的非常少)
    1)实例代码块可以编写多个,也是遵循自上而下的顺序依次执行
    2)实例代码块在构造方法执行之前执行,构造方法执行一次,实例代码块对应执行一次
    3)实例代码块也是java语言为程序员准备的一个特殊时机——对象初始化时机
5、静态方法：方法什么时候定义为静态的?
    方法描述的是动作,当所有的对象执行这个动作的时候,最终产生影响是一样的,那么这个动作不再属于某一对象,
    可以将这个动作提升为类级别的动作,模板级别的动作。
    静态方法中无法直接访问实例变量和实例方法。
    大多数方法都定义为实例方法，一般一个行为或者一个动作在发生的时候，都需要对象的参与。
    但也有例外，如：大多数“工具类”方法都是静态方法，因为工具类就是方便编程，为方便方法的调用，自然不需要new对象是最好的。
6、实例变量：
    构造方法执行时初始化，存在堆内存的java对象内部，“引用.”方式访问。
    总结:
    class 类{
        静态代码块;
        实例代码块;

        静态变量;
        实例变量;

        构造方法;
        实例方法;
    }
7、带有static的方法,其实既可以采用类名的方式访问,也可以采用引用.的方式访问；
    但是即使采用引用的方式去访问,实际上执行的时候和引用指向的对象也无关；
    带有static的方式还是建议使用"类名."的方式访问；
    所以计算使用空引用访问带有static的方法，也不会产生空指针异常的报错。
    Test t = new Test();
    //引用是空
    t = null;
    t.doSome(); //这里不会报错空指针异常

chapter03.7_类的继承、重载、覆盖

day10-类的继承笔记
1、继承是面向对象三大特征之一（封装、继承、多态）
2、继承基本的作用：代码复用，但继承最重要的作用是：有了继承才有了以后“方法的覆盖”和“多态机制”。（面试可能问，后面作用更重要）
3、继承语法格式：
    【修饰符列表】 class 类名 extends 父类名{
        类体 = 属性 + 方法;
    }
4、java语言中的继承只支持单继承，一个类不能同时继承很多类，只能继承一个类。（C++中支持多继承）
5、关于继承的一些术语：
    B类继承A类，其中：
        A类称为：父类、基类、超类、superclass
        B类称为：子类、派生类、subclass
6、java中子类继承父类都继承哪些数据呢？
    私有的不支持继承
    构造方法不支持继承
    其他数据都可以被继承
7、虽然java语言中只支持单继承，但是一个类也可以间接继承其他类，如：
    C extends B{
    }
    B extends A{
    }
    A extend T{
    }
    C类直接继承 B类，间接继承 A类、T类。
8、java语言中假设一个类没有显示的继承任何类，该类默认继承JavaSE库中提供的java.lang.Object类（老祖宗）。
    java语言中任何一个类中都有Object类的特征。

public class Account {
    private String actno;
    private double balance; //余额

    public Account() {
        super();
    }

    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

//信用卡类
public class CreditAccount extends Account {
    private String actno;
    private double balance;
    private double credit;

    public CreditAccount() {
    }

    public double getCredit() {
        return credit;
    }

    public void setCredit(double credit) {
        this.credit = credit;
    }
}

/*
继承语法格式：
    【修饰符列表】 class 类名 extends 父类名{
        类体 = 属性 + 方法;
    }
 */
public class ExtendsTest {
    public static void main(String[] args){
        ExtendsTest et = new ExtendsTest();
        String s = et.toString();   //等号右边:引用.实例方法,说明可以调用toString方法，ExtendsTest类中继承的JavaSE库中提供的java.lang.Object类中的方法
        System.out.println(s);  //ExtendsTest@1540e19d

        CreditAccount act = new CreditAccount();
        act.setActno("act-001");
        act.setBalance(-65354.8);
        act.setCredit(0.99);
        System.out.println(act.getActno() + "," + act.getBalance() + "," + act.getCredit());
    }
}

public class ExtendsTest2 {
    public static void main(String[] args) {
        C c = new C();
        c.doSome();     //这里调用的方法是从B类中继承来的doSome()方法
    }

    class A{
        public void doSome(){
            System.out.println("do Some!");
        }
    }

    class B extends A{
//        public void doSome(){
//            System.out.println("~~~do Some!~~~");
//        }
    }

    class C extends B{

    }
}

9、方法的重载
    1）方法重载又称为Overload
    2）使用时间：在同一个类中，方法完成功能相似，建议方法名相同，方便程序员编程，就像在调用一个方法，代码没变。
    3）什么条件满足之后构成方法重载？
        在同一个类当中
        方法名相同
        参数列表不同：类型、顺序、个数
    4）方法重载和什么无关？
        和方法的返回值类型无关
        和方法的修饰符列表无关

10、方法的覆盖（方法的重写）
    1）方法覆盖/重写：英语单词——Override【官方的】/OverWrite
    2）什么时候使用方法重写？——当父类中的方法已经无法满足子类中的业务需求，子类需要对继承的父类的方法进行方法重写/覆盖。
    3）代码满足什么条件之后发生方法重写？
        方法重写发生在具有继承关系的父子类之间
        方法重写的时候：方法名相同，返回值类型相同，形参列表相同，即public void move(){}中的 void move() 都不能变化
        方法重写的时候：访问权限不能更低，只能更高（只能private->public，不能public->private）
        方法重写的时候：抛出异常不能更多，可以更少 【回头讲异常】
    4）建议方法重写的时候尽量复制粘贴/工具生成，不要编写，容易出错，导致没有产生覆盖
    5）注意：
        私有方法不能继承，所以不能覆盖
        构造方法不能继承，所以不能覆盖
        静态方法不存在覆盖。【讲完多态后解释】
        覆盖只针对方法，不针对属性

public class Animal {
//    public void move() throws Exception{
    public void move(){
        System.out.println("动物在移动");
    }
}

//飞禽类
public class Bird extends Animal{
    public void move(){
        System.out.println("鸟儿在飞翔");
    }
}

public class Cat extends Animal{
    public void move(){
        System.out.println("猫在走猫步");
    }
}

public class YingWu extends Bird{
    @Override
    public void move() {
//        super.move();
        System.out.println("鹦鹉飞不起来!");
    }
}

public class OverrideTest01 {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.move();

        Cat c = new Cat();
        c.move();

        Bird b = new Bird();
        b.move();

        YingWu y = new YingWu();
        y.move();
    }
}