基础BASIC

DAY01

1.配置环境变量( JAVA_HOME CLASS_PATH path[ 不用新建 ] )

JAVA_HOME—新建—C:\Program Files\Java\jdk1.8.0_45
CLASS_PATH—新建—C:\Program Files\Java\jdk1.8.0_45\lib
path—修改(原来就有)—C:\Program Files\Java\jdk1.8.0_45\bin

2.工作空间 Ctrl+s Ctrl+F11

3.完成HelloWorld案例

—>创建项目—>包—>类—?main()—>syso(“HelloWorld”);

4.JDK JRE JVM 【拓展】

JDK -- Java开发环境<br />    JRE -- Java运行环境<br />    JVM -- 加载并运行.java文件编译产生的.class字节码文件,也是Java跨平台的原因

DAY02

1.标识符—起的名字(数字字母下划线美元符号)

2.关键字—53个 const goto没有具体的意义

3.注释 // / / /* / —注释不影响的代码的执行

4.变量 int a = 3 ; int—变量的类型 a—变量名 3—变量保存的值

成员变量:类里方法外,不需要初始化,会默认初始化,类消失,成员变量才会消失
局部变量:方法里或局部代码块中,需要手动初始化,方法执行完毕,局部变量释放

5.数据类型

基本类型(8种)
整数型 byte int short long
浮点型 flaot double
字符型 char char 类型可以保存单个字符【字母/数字/中文字符】如果存的是数字，
会去ASCII码表中找到对的字符 128-65535用问号？表示
布尔类型 boolean - false/假/0 true/真/1
引用类型(对象名数组名,保存的是地址,不是具体的值)

6.基本类型的字面值

1) 整数类型的字面值是int类型
2) 浮点型的字面值是double类型
3) byte short char 三种比int小的类型可以使用范围内的值直接赋值
4) 字面值后缀 L—long F—float D—double
5)字面值前缀 0b 0 0x \u

7.运算规则

计算的结果与最大类型保持一致
byte short char 三种比int小的类型运算时会自动提升成int类型
整数运算溢出(求光年)
浮点数运算不精确浮点数的特殊值Infinity NAN

8.口诀:小转大直接转大转小强制转浮变整,小数没

DAY03

1.运算符

++ — 自增自减运算符符号在前,先变化,再使用符号在后,先使用,再变化
& :全部为true,结果才为true,理解成”和”
| :只要有一个为true,结果就是true,理解成”或”
&& || :与&和 | 逻辑相同,只是加入了”短路”的概念,效率更高
三目运算符 : 1 ? 2 : 3 1是表达式,1的结果为true,结果取2号位置,反之,取3号位置

2.分支机构

if(判断条件){符合判断条件要执行的代码}
if(){ }else{ } 嵌套分支

3.switch

4.循环结构
for : 明确知道循环的次数,先判断再执行

public static void main(String[] args) {
        for(int i = 1; i <= 10; i++) {
            System.out.println("今天复习" + i);
        }
    }

while :不确定次数时,先判断再执行

public static void main(String[] args) {
        int i = 1;//初始化值
        while (i <= 10) {
            System.out.println("今天复习" + i);
            i++;//步进语句
        }
    }

do-while:不确定次数时,先执行再判断

public static void main(String[] args) {
        int i = 1;//初始化值
        do {
            System.out.println("今天复习" + i);
            i++;//步进语句
        } while(i <=10);
    }
}

DAY04

1.嵌套for循环

外层循环执行一次,内层循环执行多次
外层循环控制行,内层循环控制列
冒泡:外层循环控制的是轮数,内层循环控制的是每轮比较的次数

2.break与continue

DAY05

1.方法:具有一定功能的代码块

修饰符返回值类型方法名(参数){方法体}
通过方法名+参数来调用方法

2.方法的重载:

在一个类中,存在多个名字相同的方法,并且参数列表不同
(int a,int b) 和 (int b, int a) — 不构成重载
在同名的前提下,参数个数不同,一定构成重载
在同名的前提下,参数个数相同,要查看相同位置上参数的类型是否一致

3,数组:存放多个相同类型元素的结构

数组下标从0开始,最大下标是a.length-1
数组一旦创建,长度不可改变
数组的遍历—for循环遍历

4.冒泡排序

相邻比较,位置不同就互换位置,如果有n个数,最多比较n-1轮
5.Arrays.toString() sort()数组工具类排序 copyOf()数组复制

面向对象OOP

DAY06

1.是一种编程思想
2.面向对象的三大特性(封装继承多态)

类

1.是一类事物的抽象,模板
2.通过class关键字描述一个类
3.属性(成员变量)+行为(方法)

对象

1.对象是根据类具体创建出来的
2.创建对象通过new关键字来创建
对象在内存中的存储(5步)
创建对象时，内存究竟经历了什么？
（1）在栈内存中开辟一块空间，存放引用类型变量p，并把p压入栈底
（2）在栈内存中开辟一块空间，存放Phone对象
（3）完成对象的初始化，并赋予默认值
（4）给初始值完毕的对象赋予唯一的地址值
（5）把地址值交给引用类型变量p来保存

封装

1.为了提高程序的安全性和复用性
2.用private修饰属性—通过get()/set()来操作属性
3.用private修饰方法—通过在公共的方法里调用私有方法

DAY07

变量

局部变量
位置: 定义在方法里或者局部代码块中
注意: 必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;
作用域: 也就是方法里或者局部代码块中,方法运行完内存就释放了

成员变量
位置: 定义在类里方法外
注意: 不用初始化,也会自动被初始化成默认值
作用域: 整个类中,类消失了,变量才会释放

构造代码块与局部代码块

构造代码块的特点

1) 位置: 在类的内部,在方法的外部
2) 作用: 用于抽取构造方法中的共性代码
3) 执行时机: 每次调用构造方法前都会调用构造代码块
4) 注意事项: 构造代码块优先于构造方法加载

局部代码块

1) 位置: 在方法里面的代码块
2) 作用: 通常用于控制变量的作用范围,出了花括号就失效
3) 注意事项: 变量的作用范围越小越好,成员变量会存在线程安全的问题

继承

概念
继承是面向对象最显著的一个特性。
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展
新的能力。
Java 继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新
的数据戒新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。
这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。
提高复用性：只要继承父类，就能有一样的功能
注意：构造方法不能被继承

特点
1、使用 extends 关键字
2、相当于子类把父类的功能复制了一份
3、java 只支持单继承
4、继承可以传递（爷爷，儿子，孙子的关系）
5、不能继承父类的私有成员
6、继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
7、像是 is a 的关系

super关键字
1、通过 super 关键字可以使用父类的内容
2、super 代表父类的一个引用对象
3、如果用，必须出现在调用位置的第一行

方法重写Override
1、继承后，子类就拥有了父类的功能
2、那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能
3、子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)
时，会发生覆盖/复写操作，相当于修改功能
注意：
1、父类中的私有方法不能被重写
2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限

拓展

this 与 super的区别
1) This代表本类对象的引用
class Father3{ this.XXX } //this — Father3 this = new Father3();
2) super代表父类对象的引用
class Father3{ super.XXX } //this — Father3 super = new Father3();
就相当于创建了一个父类对象
3) this可以在两个变量名相同时,用于区分成员变量和局部变量
4) this 可以在本类的构造方法之间调用,位置必须是第一条语句,注意,不能相互调用,会死循环
5) super是发生了继承关系以后,子类如果想用父类的功能,可以通过super调用
6) 如果发生了重写,还想用父类的功能,需要使用super来调用
7) Super在调用父类构造方法时,必须出现在子类构造方法的第一条语句,而且如果父类中没有提供无参构造,子类可以通过super来调用父类其他的含参构造

重载Overload 与重写Override的区别

重载: 是指在一个类中的现象,是指一个类中有很多同名的方法,但是方法的参数列表不同
重写: 是指发生了继承关系以后(两个类),子类去修改父类原有的功能,子类中有一个方法签名(返回值类型方法名(参数列表) )和父类的一模一样
重载的意义: 是为了方便外界对方法进行调用,什么样的参数程序都可以找到对应的方法来执行,体现的是程序的灵活性
重写的意义:是在不修改源码的前提下,进行功能的修改和拓展

(OCP原则:面向修改关闭,面向拓展开放)
重写要求方法的修饰符: 子类权限 >= 父类的权限

DAY08
static关键字
概念：
是java中的一个关键字
用于修饰成员（成员变量和成员方法）
特点
1) 可以修饰成员变量与成员方法
2) 随着类的加载而加载，优先于对象加载
3) 只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失
4) 静态资源也叫做类资源,全局唯一,被全局所有对象共享
5) 可以直接被类名调用
6) 静态只能调用静态，非静态可以随意调用
7) static不能和this或者super共用，因为有static时可能还没有对象

静态代码块、构造代码块和局部代码块：
//总结：
//1，代码块间的执行顺序：静态代码块，构造代码块，局部代码块
//2，为什么是这样的顺序呢？
//原因：静态代码块优先于对象加载，是随着类的加载就会第一时间加载进入内存，并一直存在。专门用来完成一些需要第一时间加载并且只需要加载一次
//构造代码块是在创建对象时才会触发，专门用来提取构造方法的共性
//局部代码块是方法调用时才会触发，专门用来控制变量的作用范围

多态

概念：

多态指同一个实体同时具有多种形式。
它是面向对象程序设计（OOP）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处是：可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
水果有两种形态：水果和苹果,不关心买回来的是苹果还是西瓜,只要是水果就行 DAY01-DAY06复习（2.28-3.5） - 图2 特点
1) 多态的前提1：是继承
2) 多态的前提2：要有方法的重写
3) 父类引用指向子类对象,如：Animal a = new Cat();
4) 多态中，编译看左边，运行看右边

多态入门案例

/**本类用于测试多态*/
public class Test5 {
    public static void main(String[] args) {
        //5.创建父类对象进行测试\
        Animal a = new Animal();
        a.eat();//小动物Animal吃啥都行~~~
        //a.jump();//父类无法使用子类的特有方法
        //6.创建子类对象进行测试
        Cat c = new Cat();
        c.eat();//小猫Cat爱吃小鱼干!!!--调用的是重写以后的功能
        c.jump();
        //8.创建多态对象进行测试
        /**口诀1:父类引用 指向子类对象*/
        /**口诀2:编译(保存)看左边,运行(测试)看右边*/
        Animal a2 = new Cat();
        Animal a3 = new Dog();
        a2.eat();//eat()使用的是父类的声明,但使用的是子类的实现方式
        a3.eat();
        /**多态的出现是为了统一调用标准,向父类看齐
         * 父类提供的功能才能用,子类特有的功能用不了*/
    }
}
//1.创建父类
class Animal{
    //3.创建父类中的普通方法eat()
    public void eat() {
        System.out.println("小动物Animal吃啥都行~~~");
    }
}
//2.创建子类
class Cat extends Animal{
    //4.重写父类中的方法--对父类中的代码功能修改
    //重写:方法签名保持一致(返回值类型 方法名(参数列表) )
    // & 权限修饰符 >= 父类权限修饰符
    public void eat() {
        System.out.println("小猫Cat爱吃小鱼干!!!");
    }
    //7.定义了子类特有的方法
    public void jump() {
        System.out.println("小猫Cat跳的老高啦");
    }
}
class Dog extends Animal{
    public void eat() {
        System.out.println("小狗爱吃肉骨头!!!");
    }
}

静态变量和实例变量的区别：

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

DAY01-DAY06复习（2.28-3.5）