JAVA

插播：
快捷键：
鼠标放在红线上，然后alt+回车，选第一项implement methods，回车

---

B字节（Byte）：每逢八位一个字节，数据存储的最小单位。
b位
100Mbps宽带，b：位
百度云速度：15MB/s B：字节

1Byte=8bit
1KB（kilo千（kilometers（千米）））=1024Byte字节
1MB=1024KB
1GB=1024MB
1TB=1024GB
1PB=1024TB
1EB=1024PB
这是一个亿，
参见祖师爷
一个亿，用王健林的话说，这是一个小目标
100，0000，0000.00 一百亿，一百个小目标
正斜杠：上坡/
反斜杠：下坡

启动：win+R，输入cmd回车
切换盘符 盘符名称
进入文件夹 cd文件夹名称
进入多级文件夹 cd文件夹1\cd文件夹2\文件夹3
返回上一级 cd …
返回根路径 cd
查看当前内容 dir
清屏 cls
退出 exit

JVM：java虚拟机，实现跨平台，但本身不是跨平台，相当于韩语翻译机（Lin版JVM），日语翻译机（win版JVM），分别在韩国、日本实现翻译
JRE：JAVA runtime environment java程序运行时的环境，包含JVM和运行时所需要的核心库
JDK：java程序安装开发工具包，包含JRE和开发人员使用的工具
运行一个已有的java程序，只需安装JRE
开发一个全新的JAVA程序，必须安装JDK

public class HelloWorld {
public static void main(String[] args){
System.out.println(“Hello,W”);
}
}

//#HelloWorld与所在文件名相同
//#String的string注意大写
/第一行：public class后面代表定义一个类的名称，类是java中所有源代码的基本组织单位/
/*第二行固定写法 ，代表main方法，代表程序的起点
*/

public class HelloWorld {
public static void main(String[] args){
System.out.println(“Hello,W”);
}
}

黑色界面是为了晚上敲代码的时候不会打扰到女朋友，说的好像就有女朋友一样


对于所有源代码，写在project的src下（external libraries相当于JDK）

包是一组文件夹的名称

cn是一个大包，里面包含了itcast，itcast包含了day04，day04包含了demo01

定义方法的完整格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，…）
修饰符：现阶段固定写法public static
返回值类型：方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样，小驼峰
参数类型：进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
方法体：方法需要做的事情，若干行代码
return：1、停止当前方法
2、将后面的结果数据返回值还给调用处。
返回值：方法执行后最终产生的数据结果
方法的重载是指方法的名称相同而参数列表不同的方法。
这里的参数列表不同主要包括：

参数的类型不同
参数的个数不同(个数不同一定构成重载)
具有多个且类型不同的参数，其顺序不同构成重载
第三种情况是最容易被忽视的。比如

这里的getMax()方法，参数的个数相同参数的类型种类也相同，但是由于参数的顺序的不同也 构成重载。
这个在笔试题中可能会出现。

方法重载与下列因素有关：
1、参数个数不同
2、参数****类型不同
3、参数的多类型顺序不同

另外，方法的重载和访问修饰符以及返回值类型无关。关于返回值类型无关我们可以从构造函数的重载去理解。
我们知道构造函数是可以实现重载的，或参数类型不同或个数不同。同时我们也清楚构造函数是没有返回值类型的(连void也不能写)，而构造函数有能实现重载，因此我们可以很容易的得出，方法的重载和返回值类型无关。

方法重载与啥无关：
1、与参数的名称无关
2、与方法的返回值类型无关



v




）

定义一个类时所使用的修饰符有哪几个？每个修饰符的作用是什么？是否可以混用？
1、有四个，分别为public、abstract、final、缺省，
2、作用：
public：将一个类声明为公共类，它可以被任何对象方法。
abstract：将一个类声明为抽象类，没有实现方法，需要子类提供方法的实现，所以不能创建该类的实例。
final：将一个类声明为最终类即非继承类，表示他不能被其他类继承.
缺省：缺省修饰符时，表示只有在相同包的对象才能使用这样的类.

6.4成员变量的修饰符有哪些？各修饰符的功能是什么？是否可以混用？
成员变量的修饰符有八个，功能分别为：
Public：公共访问控制符，指定该变量为公共时，它可以被任意对象访问.
Private：私有访问控制符，指定该变量只允许自己类的方法访问，其他任何类（包括子类）的方法均不能访问此变量.
Protected：保护访问控制符，指定该类只可以被他自己的类及其子类
缺省：同一个包中的其他变量其他类可以访问此成员变量，其他包中的类则不能.
Final：最终修饰符，指定此变量的值不能改变.
Static：静态修饰符，指定该变量被所有对象共享，即所有的实例都可以使用该变量
Transient 过度修饰符，指定该变量是一个系统保留暂无特别作用的临时性变量
Volatile 易失修饰符，指定该变量可以同时被几个线程控制和修改

6.5成员方法的修饰符有哪些？各修饰符的功能是什么？是否可以混用？
Public：公共访问控制符，指定该方法为公共，它可以被任何对象的方法访问.
Private：私有访问控制符，指定该方法只能自己类的方法访问，其他任何类（包括子类）中的方法都不能访问.
Protected：保护访问控制符，指定该方法只可以被他自己的类及其子类或同一包中的其他类访问。
缺省：同一包中的其他类可以访问此成员方法其他包中的类不可以.
Final:最终修饰符，指定该方法不能重载.
Static:静态修饰符，指定不需要实例化一个对象就可以调用的方法.
Abstract：抽象修饰符，指定该方法只声明方法头，而没有方法体，抽象方法需在子类中被实现。
Synchronized：同步修饰符，在多线程程序中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程访问，运行结束后解锁.
Native：本地修饰符，指定此方法的方法体是用其他语言（如c）在程序外部编写的.

成员变量与局部变量的区别有哪些？
1、从语法形式上看，成员变量属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被public、private、static等修饰符所修饰，而局部变量则不能被访问控制修饰符及static所修饰；成员变量和局部变量都可以被final所修饰
2、从变量在内存中得存储方式上看，成员变量是对象的一部分，而对象是存在于堆内存的，而局部变量是存在于栈内存的。
3、从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而产生，随着方法调用的结束而自动消失
4、成员变量如果没有被赋初值，则会自动以类型的默认值赋值（有一种情况例外，被final修饰但没有被static修饰的成员变量必须显示地赋值）；而局部变量则不会自动赋值，必须显式地赋值后才能使用。

创建一个对象使用什么运算符？对象实体与对象的引用有何不同？
创建一个对象使用new运算符，对象实体是实在存在于堆内存中，而对象的引用是管理对象实体的，句柄存在于栈内存中.

对象的成员如何表示？
对象的成员通过对象名.对象成员来访问

在成员变量或成员方法前加上关键字this表示什么含义？
this特指成员变量

成员方法：无static



压栈：后来的人把前面的人压在下面

光标在变量上，shift+F6可以重新地给所有同名变量改名
凡是new出来的东西，都是在堆的，

关键字小写，类大写

引用类型的一般使用步骤（只要不是基本类型，那就是引用类型）
（如scanner是一个类，为引用类型）
1、导包
import 包路径.类名称；
若需要使用的目标类和当前类位于同一个包下，则可以省略导包语句不写；
只有java.lang包下的内容不需要导包，其他的包都需要import语句
（导包语句要在package后面写，在public前面写）
2、创建
类名称 对象名 =new 类名称（）；
3、使用
对象名.成员方法名（）

创建对象的标准格式：
类名称 对象名=new 类名称（）；
匿名对象：只有右边的对象，没有左边的名字和赋值运算符
注意事项：匿名对象只能使用唯一一次，下次再用不得不再创建一个对象
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象

使用匿名对象作为参数和返回值都是可以的

Random类：用来生成随机数字 使用起来亦然三个步骤
1、导包 包
import java.util.Random;
2、创建 构造方法
Random r = new Random（）；
3、使用 成员方法

1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用。

每个单词首字母都大写，故为类（米大，所以类）

数组的长度不可以发生变化
但ArrayList集合的长度是可以随意改变的

泛型

对于ArrayList来说有一个代表泛型。
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型

注意：泛型只能是引用类型，不能是基本类型

package a.b.c.d02;

import java.util.ArrayList;
public class demoArray {

    public static void main(String[] args) {
//        首先创建一个长度为3的数组，里面用来存放person类型的对象
        Person2[] array = new Person2[3];
        System.out.println(array[0]);
        Person2 one = new Person2("迪丽热巴", 18);
        Person2 two = new Person2("李白", 25);
        Person2 three = new Person2("李黑", 27);
//       将one中地址值赋值到数组的0号元素位置 。

        array[0]=one;
        array[1]=two;
        array[2]=three;
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

        Person2 person = array[1];
        System.out.println(person.getName());
        System.out.println(array[0].getName());

//        创建了一个ArrayList集合，集合的名称是list，里面装的全是string字符串类型的数据。
//        备注：从JDK1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写上的。
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);//[]
//    注意事项：对于ArrayList集合来说，直接打印得到的不是地址值，而是内容.
//        若内容为空，得到的是空的中括号：[]
//向集合添加一些数据，需要使用add方法
        list.add("赵丽颖");
        list.add("赵");
        list.add("赵丽");
        list.add("赵丽颖0");
        System.out.println(list);
    }
}

除了基本类型，就是引用类型
集合里面保存的都是地址值，基本类型的数据没有地址值，故ArrayList=泛型只能是引用类型

若希望向集合ArrayList当中存储基本类型，必须使用基本类型对应的“包装类”。

基本类型 包装类（引用类型，包装类都位于java.lang包下）
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean


从JDK1.5开始，支持自动装箱、自动拆箱
自动装箱：基本类型->包装类型
自动拆箱：包装类型->基本类型

空指针.方法 会报错，所以推荐"…".equals(str);






数组.length无括号




变量名.fori

上页则不行，输出lengh=0
下页才成功


如果没有static关键字，那么首先创建对象，然后通过对象才能使用他
对于静态方法，可以通过对象名进行调用，也可以直接通过类名称来调用





方法区：存储.class相关信息，如main方法，。。。，其中，方法区当中有一块独立的空间，叫静态区，专门存储static的数据

new出来的对象都在堆上

静态的内容不用new，直接通过类名称就能点



chars.fori
正序：生成：
for（int i=0；i<chars.length;i++）{
}

chars.forr
倒序：生成：
for（int i=chars.length-1;i>=0;i–）{
}

面向对象三大特征：封装性、继承性、多态性
继承是多态的前提，没有继承就没有多态

案例：
Extends.class

package a.b.c.d02;

/*
在继承的关系中，子类就是一个父类，也就是说，子类可以被当作父类看待
例如，若父类是员工，子类是讲师，那么，“讲师就是一个员工”。关系：is-a
定义父类的格式：（一个普通的类定义）
public class 父类名称{
    成员变量、构造方法、成员方法。。。
}
定义子类的格式：
public class 子类名称 extends 父类名称{
    。。。
}

 */
public class Extends {
    public static void main(String[] args) {
        //
        Teacher teacher = new Teacher();
        teacher.method();
        //Teacher类虽然什么都没写，但继承了来自父类的method方法。
        //创建另一个子类助教的对象
        Assistance assistance=new Assistance();
        assistance.method();
        
    }
}

Assistance.class

package a.b.c.d02;
//定义了员工的另一个子类：助教
public class Assistance extends Teacher {

}

Employee.class

package a.b.c.d02;
//定义一个父类：员工
public class Employee {
    public void method(){
        System.out.println("方法执行！");
    }
}

teacher.class

package a.b.c.d02;
//定义了一个员工的子类：讲师
public class Teacher extends Employee {

}

在父子类继承关系当中，若成员变量重名，在创建子类对象时，访问有两种方式：
直接通过子类对象访问成员方法 直接：new上一个子，然后点它
等号左边是谁就优先用谁，没有则向上找；到处都没有，编译报错
间接通过成员方法访问成员变量

案例：

直接：new上一个子，然后点它，等号左边是谁就优先用谁，没有则向上找；到处都没有，编译报错

案例2



案例3：
父类当中的成员变量：

子类当中成员变量 int num
子类方法的局部变量（method里面的num）

/*
局部变量：            直接写成员变量名
本类的成员变量： this.成员变量名 
父类的成员变量： super.成员变量名
*/

案例四 方法：






注意：

不报错，但若Zi方法是Object，Fu的方法是String，则会报错。

public class string0 {
    public static void main(String[] args) {
        int[][] a = new int[5][5];
        int k = 1;
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j <= i; j++) {
                a[i - j][j] = k++;       /* 刚好就是成题目的角度赋值     */
            }
        }

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5 - i; j++) {
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Ctrl + D 复制光标所在行 或 复制选择内容，并把复制内容插入光标位置下面 （必备）

2、



先父类，后子类

继承关系中，父子类构造方法的访问特点：
1、子类构造方法当中，有一个默认隐含的“super（）”调用，所以一定先调用的父类构造，后调用子类构造…

有无super（）；都一样
2、可以通过super关键字来子类构造调用父类重载关键字
（赠送的super（）一定是无参，所以调用父类的重载方法会）

3、super的父类构造调用，必须是子类构造方法的第一个语句.，不能一个子类构造调用多次super构造.
如：

总结：子类必须调用父类构造方法，不写则赠送super（）.写了则用写了的super调用.,且super只能有一个，还必须是 第一个 语句的位置

super关键字的用法有三种
1、在子类的成员方法中，访问父类的成员变量.

2、在子类的成员方法 中，访问父类的成员方法

3、在子类的构造方法中，访问父类的构造方法.

super是访问父类，this是访问本类

this关键字用法也有三种：
1、在本类的成员方法中，访问本类的成员变量.

2、 在子类的成员方法中，访问本类的另一个成员方法

3、在本类的构造方法中，访问本类的另一个构造方法.




上面死亡循环，不可执行

80.min

(父类中num为10)

覆盖重写override

内存图：栈、堆、方法区
程序要想运行，方法区最先有东西

main方法先运行，所以先进栈，而new的东西都在堆里。

调用show方法，show进栈

zi.method进栈

其中，因为zi.method中有特殊的一行，super.method（），所以让method.fu（）进栈

method （fu）运行完后 xx
method （zi）运行完后 xx
show（） 运行完后 xx
Zi zi 运行完后xx
栈空，运行完毕

java是单继承，一个类的直接父类只能有一个





如上图报错就是因为抽象方法所在的类不是抽象类

如何使用抽象类和抽象方法。
1、不能直接创建new抽象类对象，必须具体
2、必须用一个子类来继承抽象父类.
3、子类必须覆盖重写抽象父类当中所有的抽象方法.
4、创建子类对象进行使用
覆盖重写（实现）：去掉抽象方法的abstract关键字，然后补上方法体大括号

//猫吃鱼

---

快捷键：
鼠标放在红线上，然后alt+回车，选第一项implement methods，回车

这就是你需要覆盖重写的，回车就出来了



（因为子类当中赠送了super）

---

29min54发红包
接口



接口使用步骤
1、接口不能直接使用，（不能直接new），必须有一个“实现类”（即子类）来“实现”（与extends差不多）该接口
格式：
（子类继承父类：public class 类名称 extends 父类）
子类继承父类：public class 实现类名称 implements 接口名称{
。。。。
}
2、接口的实现类必须覆盖重写（实现）接口中的所有抽象方法。
实现：去掉abstract关键字，再加上方法体{}
3、创建实现类的对象，进行使用。
注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类

---

接口升级了，增加了一个抽象方法，导致实现类都报错了
一个个添加覆盖重载较为繁琐，所以可以将新添加的abs2方法拥有一种默认的方法体。
将新添加的方法，改为默认方法

默认方法会被实现类继承下去



上图即实现类覆盖重写了接口的methodDefault，调用时会执行实现类的methodDefault

---

减少重复代码，但有所不妥

正确改造代码：

methodcommon的修饰符变成了private，此时如下图报错

这时只有接口内的两个类可以使用methodcommon

若是静态方法：

产生了重复代码，现进行改造，

只有methodstatic1、2才能用methodstaticcommon，其他人都用不了

（静态的东西用起来非常简单，接口名称.方法名）

package lian;
/*
接口当中也可以定义“成员变量”，但必须使用public static final三个关键字进行修饰.
从效果上看，这就是接口的【常量】
public static final 数据类型 常量名称=数据值；
此为接口当中常量的定义格式.

注意：
1、接口当中的常量，可以省略public static final，注意：不写也照样是这三个
2、接口当中的常量，必须进行赋值
3、接口常量的名称，用大写字母和下划线分隔（推荐）

 */
public interface MyinterfaceConst {
    public static final int NUM=10; //这其实就是一个常量，一旦赋值，不可修改.  public是指接口里面外边、实现类都可以用
        //用了static便与对象无关了，直接接口名称.就可以点出来了；一旦使用final关键字修饰，说明不可改变
}

package lian;

public class Myinterfaceconst1 {
    public static void main(String[] args) {
        System.out.println(MyinterfaceConst.NUM);
    }

}

3中，若覆盖重写了，则用实现类的，否则用接口里的.

直接父类只有一个，而接口可以有很多个

如果实现类

---

最终sout父类方法，故父类方法优先，接口其次。

---

4、多态

---

示例：

首先，method是成员方法，右边new的谁就运行谁的方法，故输出子类方法
多态：左父右子
多态存在要有三个必要条件：继承，方法的重写，父类引用指向子类的对象。没有实现接口

继承关系中，我们了解了成员变量访问特点，若用了多态的写法，那么成员变量的访问特点，也没有任何变化.
如：



故输出10；（没有则向上查找，不会向下查找的，若Fu中没有age这个成员变量，则错误）

注意：成员变量不能进行覆盖重写.只有成员方法才可以.
2、间接通过成员方法访问

java的话, int 是基本类型,不在面向对象体系之内,不存在继承 / 方法 / 多态 这些概念，所以Object a=new int();左父




若覆盖重写了，则子类

多态和不是多态没有任何不同.

成员方法的规则也没有变化.（如上上的示例）

成员方法：编译看左边，运行看右边
（成员变量不是如此）
成员变量：编译看左边，运行还看左边
（左右指的是new的左右）



编译看左，运行看右



38min多态重点-------------------------------------

46min

向下转型示例：





56min笔记本
object祖宗类，所有类不写都继承之

final关键字代表最终、不可改变的




因为abstract一定要覆盖重写，而final不可以被覆盖重写

地址值不能变，但方法可变

7.4构造方法有哪些特性？
1、 构造方法的方法名与类名相同
2、 构造方法没有返回值，但不能写void
3、 构造方法的主要作用是完成对类对象的初始化工作
4、 构造方法一般不能有编程人员显式地调用，而是用new来调用
5、 在创建一个类的对象的同时，系统会自动调用该类的构造方法为新对象初始化

7.5在一个构造方法内可以调用另一个构造方法吗？如果可以，如何调用？
可以；通过this来调用，而且this关键字必须写在构造方法内的第一行位置.

7.6静态变量与实例变量有哪些不同？
静态变量是隶属于类的变量，而不是属于任何一个类的具体对象，静态变量不需要实例化就可以使用。
实例变量是隶属于对象的变量，是属于具体的一个类的，是需要把类实例化为对象才可以使用的

7.7静态方法与实例方法有哪些不同？
静态方法实质是属于整个类的方法，而实例方法是属于某个具体对象的方法

7.8在一个静态方法内调用一个非静态成员为什么是非法的？
静态方法是属于整个类的，所以它不能 操纵和处理属于某个对象的成员，而只能处理属于整个类的成员，即静态方法只能访问静态成员变量或静态成员方法

报错


ctrl+/注释所有
构造方法赋值：

注意：
sub是demo02的子包，但Myson和Myclass不在同一个包中！，只要不是严格的同一个包，要调用那就得导包



以后构造方法不用自己打，可以如下


则直接重写好了







1：“==”如果前后比较的是对象，则比较的是对象的地址，如果前后为数字，则比较的是值；

2：“equals”如果前后是对象，比较的是对象的地址，如果比较的对象重写了“equals”方法，则比较的是值；

（八个基本数据类型的封装类：Byte，Short，Integer，Long，Float，Double，Boolean，Character比较的都是值，还有File，Date等）

修改版

也可以自己覆盖重写




即可直接生成：


直接就给调用了ToString方法




为什么str是输出abc，而s是输出地址

this代表当前的一个字符串对象，所以string已经对Tostring进行了重写
而Student类没有覆盖重写，则默认调用object类，

object类中ToString的覆盖重写方法不一样，所以返回包名+类名+@+hashcode的方法，即为地址值

对Student的ToString中进行覆盖重写

自动生成ToString方法



一个true一个false 的原因：

String重写了，所以比较的就是两个字符串内容
而学生类的没有重写，所以继承了object类的equals方法
==号可以比较基本数据类型和引用数据类型
比较基本数据类型比较的就是两个具体的值，若比较引用数据类型，比较的就是两个地址值
而两个new出来的都在堆里，（牛堆），所以地址值必然不同


objects中：


所以不会报安全问题，通过objects覆盖重写：

object：出问题






方法外边，直接在类内部就为成员

内部类命名格式



this.num：20
super.num却用不了：因为内部类并不是继承外部类，其继承的仍然是object类


外界要访问inner做不到，因为只有当前所属 方法才能使用，出了就不能用了，所以先创建一个Inner

相当于调用一个普通的外部类对象methidOuter

因为外部类已经最外面了，所以没有子类，所以只能public/（default）

局部classInner只有自个才能访问，所以什么都不写




匿名内部类：

抽象方法不能直接用，需要一个实现类实现它


若用多态（左父右子），亦没有问题

之前说过接口不能直接new

所以我们new了后在后面多点东西

此方法可以省略类的单独创建


亦可实现





秀我一脸

DATE类

在这里插入图片描述







鼠标选中此方法，alt+回车


而main方法调用了此方法，所以也得抛出异常

package com.company;
import java.util.Calendar;
/*
java.util.Calendar类：日历类
Calendar类是一个抽象类，里面提供了许多操作日历字段的方法（如YEAR、HOUR、DAY of MONTH、HOUR）
Calendar类无法直接创建对象使用，里面有个静态方法叫getInstance，该方法返回了Calendar的子类对象
static Calendar getInstance（）使用默认时区和语言环境获得一种日历
 */
public class calendar {
    public static void main(String[] args) {
        Calendar c=Calendar.getInstance();//多态
        System.out.println(c);
    }
}

输出结果：
java.util.GregorianCalendar[time=1607512570473,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id=“Asia/Shanghai”,offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=11,WEEK_OF_YEAR=50,WEEK_OF_MONTH=2,DAY_OF_MONTH=9,DAY_OF_YEAR=344,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=7,HOUR_OF_DAY=19,MINUTE=16,SECOND=10,MILLISECOND=473,ZONE_OFFSET=28800000,DST_OFFSET=0]

Process finished with exit code 0

package com.company;
import java.util.Date;
public class data {
    public static void main(String[] args) {
        //空参构造方式
        Date d=new Date();
        System.out.println(d);
    }
}

可以按照我们熟悉的时间格式

package com.company;
import java.util.Date;
public class data {
    public static void main(String[] args) {
        //空参构造方式
        Date d=new Date();
        System.out.println(d.toLocaleString());
    }
}

package com.company;
import java.util.Date;
public class data {
    public static void main(String[] args) {
        //空参构造方式
        Date d=new Date(3000L);//三千毫秒
        System.out.println(d.toLocaleString());
    }
}

时间起点英国的1970.1.1.0.0 中国东八区，所以八点
3000L故3秒

package com.company;
import java.text.SimpleDateFormat;
import java.util.Date;
public class data {
public static void main(String[] args) {
//空参构造方式
Date d=new Date(3000L);//三千毫秒
SimpleDateFormat sdf=new SimpleDateFormat(“yyyy年MM月dd日 HH：mm：ss”);
System.out.println(d.toLocaleString());
String f= sdf.format(d);
System.out.println(f);
}
}


可自动生成代码

会有异常，先将其抛出

package com.company;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class data {
    public static void main(String[] args) throws ParseException {
        //空参构造方式
        Date d=new Date(3000L);//三千毫秒
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
        System.out.println(d.toLocaleString());
        String f= sdf.format(d);
        System.out.println(f);
        String str=("2088年08月08日 08：08：80");
        Date parse = sdf.parse(str);
        System.out.println(parse);
    }
}

注意：国外的月份是从0到11，所以MONTH要加1

输出2088年

输出20990年（也可以add负数）




方法重载

getTime把日历对象转化为日期对象

有课后
一看到缓冲区，则可以提高操作效率



append返回值是StingBuilder，所以new一个StringBuilder的bu2接收
比较地址值，两者地址值相等


bu1调用的，所以返回bu1（即this）



应用currentTimeMillis、arraycopy:
为工具类，里面都是静态的方法，所以首先不用创建这些对象


当前时间距1970年





字符串是引用型变量，而基本数据类型是数值变量， 引用型变量就像C语言里面的指针存放的是该字符串的地址。计算机存储的数据都有一个编号就是地址。字符串就是存放的地址；
比如有两个数值型的数据判断是否相等，直接用‘’就行了，
但是引用变量就不一样了。比如String s1=“123”;假设这个字符串在计算机的地址&s1=Oxffa00fff; String s2=“123”; 假设这个字符串在计算机的地址是&s2=Oxffa000f0; 如果你像这样比较 s1==s2 返回的是false;因为你这样比较就是他们地址的比较 Oxffa00fff=Oxffa000f0 ? 明显不等，这时就要调用java中字符串的方法equals(); s1.equals(s2) 返回true








就是一个字符串，所以直接连接而不是加法



数字格式化异常

public class Employee {
    private String name;
    private int age;
    private double salary;
    public Employee(String newName,int newAge,double newSalary){
        this(newAge,newSalary);
        System.out.println("三个参数的构造方法被调用");
        name=newName;
    }
    public Employee(int newAge,double newSalary){
        this(newSalary);
        System.out.println("两个参数的构造方法被调用");
        age=newAge;
    }
    public Employee(double newSalary){
        this.getAge();
        System.out.println("一个参数的构造方法被调用");
    }
    public Employee(){
        System.out.println("没有参数的构造方法被调用");
    }
    void setAge(int newAge){
    int age=0;
    age=newAge;
    }
    int getAge(){
        return age;
    }

    public static void main(String[] args) {
        Employee s1=new Employee("李四",31,8000);
        s1.setAge(31);
        System.out.println("年龄是"+s1.getAge());
    }
}

public class Ca {
    int a;
    static int b;
    public static void m1() {
        Ca s1=new Ca();
        s1.a=10;
        b=10;
    }
    public static void m2() {
        Ca s1=new Ca();
        s1.a=5;
        b=5;
    }
    public static void m3() {
        m1();
        Ca s1=new Ca();
        s1.m2();
    }

}

静态方法不能访问类的其他成员（成员变量或成员方法），除非这些成员也被声明为static，即静态方法不能直接处理费静态的成员，非静态成员只能通过对象来访问，即在访问非静态成员前需先创建一个对象，创建对象后，再去通过对象访问非静态成员（如上）
（因为静态的先有，非静态后有）

数组长度不可变，所以学了ArrayList集合()



set反而无序

打印的不是地址，所以重写了方法

使用迭代器取出集合中元素的代码，是一个循环的过程
所以我们可以使用循环优化
不知道集合中有多少元素，使用while循环
循环结束条件：hasNext方法返回false

new了一个ArrayList，所以内存的堆中有的ArrayList

取出元素，然后指针后移

List下面的可以索引，而set下面的不可以，所以使用一种两者都可的遍历方式：迭代器、增强for.
A、通过集合对象获取迭代器对象
B、使用循环遍历迭代器
C、判断迭代器对象中是否还有元素
D、有元素则获取


拿到第一个元素，赋值给i，拿到第二个元素，赋值给i

只要遍历，就增强for循环

import java.util.ArrayList;
import java.util.Iterator;
public class iteractor2 {
    public static void main(String[] args) {
        show01();
    }
    /*创建集合对象，不使用泛型：
    好处：集合不使用泛型，默认的类型就是object类型，可以存储任意类型的数据.
    弊端：不安全，引发异常.
* */
    private static void show01() {
        ArrayList list=new ArrayList();
        list.add("ddd");
        list.add(1);
        //获取迭代器，使用迭代器遍历list集合
        Iterator it=list.iterator();
        //使用迭代器的方法hasNext和next遍历集合
        while(it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);

        //上面没问题，但若想要使用String特有的方法，length获取字符串的长度，不能使用多态，Object obj="ddd",
        // 多态的弊端，不能使用子类特有的方法，需要向下转型，把Object变成字符串
            //会抛出ClassCastException异常，不能把Integer类型转换为String类型，"ddd"转成功了，但1不能
        String s=(String)obj;
            System.out.println(s.length());
            System.out.println(((String) obj).length());//或者第二种写法
        }
    }
}

可以使用length方法


改为泛型：所有使用数据类型的地方，都改为泛型




**************************uihuh

--------------死神



222222222222222222


44min

调用父类构造方法

类型不太确定，所以改用通配符？表示，方正确

？定义的时候不能用，但作为参数传递可用











不是同步的=》多线程=》快

50min