java后端系统学习总结 01_java第五版 java初学笔记，由浅入深

java第五版最终版

.class文件是虚拟机编译得到的，虚拟机需要把我们写的.java文件编译成它可执行的字节文件

1.Java学习中会遇到哪些文件？

.java文件 .class文件

.java文件是源文件，也就是我们自己写的代码。

.class文件是虚拟机编译得到的，虚拟机需要把我们写的.java文件编译成它可执行的字节文件。

dos命令找到文件位置

javac+文件全名 生成.class文件； java+文件名 输出所写代码

.java文件经过JRE中

1.注释三种

单行注释 多行注释 文档注释（/* * * * */）

2.标识符

不能关键字（区分大小写），保留字

3.大小驼峰 java命名规范

4.四类八种 大小转换

1.（四类八种）

基本数据类型：整型、浮点型、逻辑型（布尔型）、字符型

整型：byte、short、int、long（后面要加L）; 浮点型：float（后面加F）、double；

布尔型：boolean； 字符型：char；

​ 2.（八种的转换大小）

隐式转换：byte、short、char—int—long—float—double（低——高）

强制转换：目标类型 变量名=（目标类型）（被转换的数据） byte c=（byte)(a+b）

字节： byte char short int long float double·

字节数：1 2 2 4 8 4 8

基本数据类型、引用数据类型（数组、类、接口->默认值都为null）

**在Java中类型可分为两大类：值类型与引用类型。**值类型就是基本数据类型（如int ,double 等），而引用类型,是指除了基本的变量类型之外的所有类型（如通过 class 定义的类型）。所有的类型在内存中都会分配一定的存储空间(形参在使用的时候也会分配存储空间,方法调用完成之后,这块存储空间自动消失), 基本的变量类型只有一块存储空间(分配在stack中), 而引用类型有两块存储空间(一块在stack中,一块在heap中)

深入了解java引用数据类型

什么是引用

Java 是传值还是传引用，问题主要出在对象的传递上，因为 Java 中简单类型没有引用。既然争论中提到了引用这个东西，为了搞清楚这个问题，我们必须要知道引用是什么。

简单的说，引用其实就像是一个对象的名字或者别名 (alias)，一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似 C++ 语言中指针的东西，它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。

如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间（stack，栈空间）来保存。但是它们的值是相同的，都指示同一个对象在内存（heap，堆空间）的中位置。比如：

String a=“This is a Text!”;

String b=a;

通过上面的代码和图形示例不难看出，a 和 b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象 “This is a Text!”。但要注意String 对象的值本身是不可更改的 (像 b = “World”; b = a; 这种情况不是改变了 “World” 这一对象的值，而是改变了它的引用 b 的值使之指向了另一个 String 对象 a)。
　　

如图，开始b 的值为绿线所指向的“Word Two”，然后 b=a; 使 b 指向了红线所指向的”Word“.

这里我描述了两个要点：

（1） 引用是一种数据类型（保存在stack中），保存了对象在内存（heap，堆空间）中的地址，这种类型即不是我们平时所说的简单数据类型也不是类实例(对象)；

（2） 不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。

那么对象（记住在Java中一切皆对象，无论是int a;还是String a;，这两个变量a都是对象）在传递的时候究竟是按什么方式传递的呢？

其答案就只能是：即是按值传递也是按引用传递，但通常基本数据类型（如int,double等）我们认为其是“值传递”，而自定义数据类型（class）我们认为其是“引用传递”。

堆、栈、引用变量:

数据类型详细介绍

整型（byte、short、int、long）

虽然byte、short、int、long 数据类型都是表示整数的，但是它们的取值范围可不一样。

byte 的取值范围：-128～127（-2的7次方到2的7次方-1）

short 的取值范围：-32768～32767（-2的15次方到2的15次方-1）

int 的取值范围：-2147483648～2147483647（-2的31次方到2的31次方-1）

long 的取值范围：-9223372036854774808～9223372036854774807（-2的63次方到2的63次方-1）

由上可以看出 byte、short 的取值范围比较小，而long的取值范围时最大的，所以占用的空间也是最多的。int 取值范围基本上可以满足我们的日常计算需求了，所以 int 也是我们使用的最多的一个整型类型。

浮点型（float、double）

float 和 double 都是表示浮点型的数据类型，它们之间的区别在于精确度的不同。

float（单精度浮点型）取值范围：3.402823e+38～1.401298e-45（e+38 表示乘以10的38次方，而e-45 表示乘以10的负45次方）

double（双精度浮点型）取值范围：1.797693e+308～4.9000000e-324（同上）

double 类型比float 类型存储范围更大，精度更高。

通常的浮点型数据在不声明的情况下都是double型的，如果要表示一个数据时float 型的，可以在数据后面加上 “F” 。

浮点型的数据是不能完全精确的，有时候在计算时可能出现小数点最后几位出现浮动，这时正常的。

字符型（char）

char 有以下的初始化方式：

char ch = ‘a’; // 可以是汉字，因为是Unicode编码

char ch = 1010; // 可以是十进制数、八进制数、十六进制数等等。

char ch = ‘\0’; // 可以用字符编码来初始化，如：’\0’ 表示结束符，它的ascll码是0，这句话的意思和 ch = 0 是一个意思。

Java是用unicode 来表示字符，“中” 这个中文字符的unicode 就是两个字节。

String.getBytes(encoding) 方法获取的是指定编码的byte数组表示。

通常gbk / gb2312 是两个字节，utf-8 是3个字节。

如果不指定encoding 则获取系统默认encoding 。

布尔型（boolean）

boolean 没有什么好说的，它的取值就两个：true 、false 。

四、基本类型之间的转换

将一种类型的值赋值给另一种类型是很常见的。在Java中，boolean 类型与其他7中类型的数据都不能进行转换，这一点很明确。但对于其他7种数据类型，它们之间都可以进行转换，只是可能会存在精度损失或其他一些变化。

转换分为自动转换和强制转换：

自动转换（隐式）：无需任何操作。

强制转换（显式）：需使用转换操作符（type）。

将6种数据类型按下面顺序排列一下：

double > float > long > int > short > byte

如果从小转换到大，那么可以直接转换，而从大到小，或char 和其他6种数据类型转换，则必须使用强制转换。

强制转换 默认转换 final

doublt（D）

运算符

5.运算符 =和==（判断） %（取余）instanceof判断两个类有无继承关系 逻辑运算符 三目运算

8.运算符的优先级及运算符https://blog.csdn.net/weixin_36255837/article/details/114071597?ops_request_misc=&request_id=&biz_id=102&spm=1018.2226.3001.4187

除法运算，两个操作数是整型的，结果也会是整型的，舍弃掉小数部分；如果有一个数是浮点数，结果将自动转型为浮点型

取余运算，两个操作数是整型的，结果也会是整型的，如果有一个数是浮点数，结果将自动转型为浮点型

a++和++a i++是先参加运算，然后再自增；++i是先自增，后参加运算

instanceof 运算符： 该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

优先级：单算移关与，异或逻条赋 括号级别最高，逗号级别最低，单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值。

位运算符

含义运算规则

& 按位与 两个操作数都为1，结果为1

| 按位或 两个操作数一个为1，结果为1

^ 按位异或 两个操作数相同为0，不同为1

~ 按位取反 操作数为1，结果为0；操作数为0，结果为1

<< 左移 右边空位补0

“>>” 右移 左边空位补最高位，即符号位

“>>>” 无称号右移 左边空位补0

示例: a和b是两个整数，下面是按位计算的形式

a = 0011 1100 ;

b = 0000 1101 ;

a & b = 0000 1100 ;

a | b = 0011 1101 ;

a ^ b = 0011 0001 ;

~a = 1100 0011 ;

a<<2 = 1111 0000 ;

a>>2 = 1111 ;

a>>>2 = 0000 1111 ;

运算符 “|” 和 “||” 以及 “&” 和 “&&” 区别 “a++”和“++a”的区别

|运算符：不论运算符左侧为true还是false，右侧语句都会进行判断，

int a = 1, b = 1;
if (a++ == 1 | ++b == 2) {
    System.out.println("true");
}
System.out.println("a= " + a + "  ,b=  " + b);
左侧为true，右侧为true，输入出结果为：
true
a= 2  ,b=  2

||运算符：左侧为ture时，右侧语句就不会进行判断了

int a = 1, b = 1;
if (a++ == 1 || ++b == 2) {
    System.out.println("true");
}
System.out.println("a= " + a + "  ,b=  " + b);
左侧为true，所以没有判断运算符右侧语句，输出结果为：
true
a= 2  ,b=  1

& 左侧为ture还是false右侧都会进行判断

&& 左侧为false时，不再进行对右侧语句的判断

int left = 3；
//		left  3 4 5    		left 3 4 5      
		while(left<a.length &&  a[left++]==b){//4 5 6
//		left  3 4 5			left 4 5 6
//		while( a[left++]==b && left<a.length){//4 5  执行两次没有6，因为6不能通过第二个条件			
			counter++;	
//		left 4 5 6
			System.out.println(left);
		}

==============================================

一、二、三元运算符

一元运算符：

序号	一元运算符	说明
1	i++	给i加1
2	i–	给i减1
3	++i	给i加1
4	–i	给i减1

二元运算符

序号	二元运算符	说明
1	+	加
2	-	减
3	*	乘
4	/	除
5	%	取余

三元运算符（三目运算）

int i    =    150;
int c    =    i<100?100:200;
System.out.println(c);

7.短路运算 &和|的结果

9.公式的练习

if if else 多种选择

switch case break default

双for

scanner

while

1+···+100

大题乘法表 杨辉三角之间

增强型for循环（建议不要用）

for套switch （大题）

写思路分析（多得分）

数组名。length

冒号排序

java常用的八种排序方式：https://blog.csdn.net/qq_23994787/article/details/77965750?ops_request_misc=&request_id=&biz_id=102&spm=1018.2226.3001.4187

break contidue retun（写在最后）

一、作用不同

1、break：执行break操作，跳出所在的当前整个循环，到外层代码继续执行。

2、continue：执行continue操作，跳出本次循环，从下一个迭代继续运行循环，内层循环执行完毕，外层代码继续运行。

3、return：执行return操作，直接返回函数，所有该函数体内的代码（包括循环体）都不会再执行。

二、结束不同

1、break：break不仅可以结束其所在的循环，还可结束其外层循环，但一次只能结束一种循环。

2、continue：continue结束的是本次循环，将接着开始下一次循环。

3、return：return同时结束其所在的循环和其外层循环。

java中什么是实例化

Demo demo = new Demo();
通常把这条语句的动作称之为创建一个对象，也就是实例化，其实，它包含了四个动作。

1）右边的“new Demo”，是以Demo类为模板，在堆空间里创建一个Demo类对象（也简称为Demo对象）。

2）末尾的()意味着，在对象创建后，立即调用Demo类的构造函数，对刚生成的对象进行初始化。构造函数是肯定有的。如果你没写，Java会给你补上一个默认的构造函数。

3）左边的“Demo demo”创建了一个Demo 类引用变量。所谓Demo类引用，就是以后可以用来指向Demo对象的对象引用。

4）“=”操作符使对象引用指向刚创建的那个Demo对象。

访问修饰符作用范围

非访问修饰符：

static

解释一

参考链接

static修饰符可以被应用在变量、方法、代码段和内部类中。如果需要Java实例变量被存储在单独的内存中，或需要变量对一个单独类的所有对象所通用，那么静态修饰符需要被应用在该变量的声明中。

静态方法：Java的静态方法对类是通用的并且并不和Java实例相关联。尽管静态方法能够自由的访问类的静态数据和方法，但是它们并不能使用类的非静态功能。静态方法不能够被重载为非静态的。对于Java静态方法不能够使用this关键字。

静态块：静态代码块在类加载时只执行一次。先与构造函数执行。

静态变量：Java的实例变量使用单独的空间进行存储。如果需要变量对一个类的所有对象都是通用的，那么这个变量就需要被声明为静态的。类的所有实例对象都可以修改该类的静态变量。此外，使用对象实例修改静态成员并不是唯一手段，也可以直接使用java类来修改。静态变量也可以被Java对象的方法所访问。当一个常量的值在编译器就已经知晓了，它就需要使用static关键字来声明为final类型。

静态内部类：只有内部类能够使用static修饰符来声明，在Java中它被称为静态嵌套类。

解释二

static可以修饰: 属性，方法，代码段，内部类（静态内部类或嵌套内部类）

static 表示静态或全局，它可以修饰属性，方法和代码块。由于静态属性和方法是属于该类的所有对象的，所以可以用类名.静态属性/方法名来访问。用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块。

特点

static修饰符，用于修饰成员(成员变量和成员函数)。

1.static静态方法只能访问静态成员，不可以访问非静态成员。静态方法在加载时，优先于对象存在，故而没有办法访问对象中的成员。
2.静态方法中不能使用this，super关键字。
3.因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

a.static变量
被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量
static不能修饰局部变量
static修饰的变量可以被修改
b.静态方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是非static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！
父子类中，静态方法只能被静态方法覆盖，父子类中，非静态方法只能被非静态方法覆盖。
java中的main方法必须写成static的因为，在类加载时无法创建对象，因为静态方法可以不通过对象调用，所以在类的main方法所在在类加载时就可以通过main方法入口来运行程序。
c.static代码块
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

解释三

语法规定：静态成员不能直接访问非静态成员。static不能访问非static方法

final

final: 用来修饰类、方法和变量

a.final修饰变量
被final修饰的变量就会变成常量（常量应当大写），一旦赋值不能改变，final的常量不会有默认初始值，对于直接在初始化赋值时final修饰符常和static修饰符一起使用。
b.final修饰方法
被final修饰的方法将不能被其子类覆盖重写
c.final修饰类
被final修饰的类将不能被继承。final类中的方法也都是final的
注意：
final不能用来修饰构造方法，在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类的类加载。

abstract

解释一

abstract: 用来创建抽象类和抽象方法

abstract修饰符适用于类和方法。抽象类不能够被实例化，它必须被继承才能够访问。abstract不能够应用到类的成员变量。

注意：

• 如果类包含一个或多个抽象方法，编译器将强制该类必须声明为抽象的。
• abstract类和final类是相对的。final类不能够被继承，而抽象类必须被继承。
• 抽象类不一定拥有抽象方法，但是通常会有抽象方法。

设计上，你希望基类对继承类仅仅只作为接口。这意味着你不希望任何人实例化该基类。你只想进行向上类型转换（隐式转换，它能够提供多态性），这样就只能使用该基类的接口了。这是通过使用abstract关键字来修饰该类实现的。

提供限制来不实例化抽象类，这样就需要任何使用该抽象类的人来实现它，并提供多态性。

解释二

*抽象类（abstract class）：*

使用abstract修饰符修饰的类。抽象类里可以没有抽象方法，但有抽象方法的必须是抽象类，否则编译器会报错。

***抽象方法：***只声明，不实现。

*接口（interface）：*

定义：接口在java中是一个抽象类型，是抽象方法的集合。一个类通过继承接口的方式，从而继承接口的抽象方法。从定义上看，接口是个集合，并不是类。类描述了属性和方法，而接口只包含方法（未实现的方法）。

接口和抽象类一样不能被实例化，因为不是类。但是接口可以被实现（使用 implements 关键字）。实现某个接口的类必须在类中实现该接口的全部方法。虽然接口内的方法都是抽象的（和抽象方法很像，没有实现）但是不需要abstract关键字。

1. 接口中没有构造方法（因为接口不是类）
2. 接口中的方法必须是抽象的（不能实现）
3. 接口中除了static、final变量，不能有其他变量
4. 接口支持多继承（一个类可以实现多个接口）
5. 接口中没有构造器，可以实现多继承，只有final和static，方法是抽象的

synchronized和volatile

synchronized和volatile:主要用于线程的编程

static final

static final和final static没什么区别，一般static写在前面。
static修饰的属性强调它们只有一个，final修饰的属性表明是一个常数（创建后不能被修改）。static final修饰的属性表示一旦给值，就不可修改，并且可以通过类名访问。
static final也可以修饰方法，表示该方法不能重写，可以在不new对象的情况下调用。

补充

static修饰符

 1> 静态变量：无论实例化多少对象，它的静态变量只有一份
 2> 静态方法： 静态方法不能访问类的非静态变量

final修饰符

  1> final变量：被final修饰的变量必须指定初始值，变量一旦赋值，就不能修改
  2> final方法：可以被子类继承，但不能被子类修改
  3> final类：不能被继承

abstrac修饰符

         		 抽象类：1> 抽象类不能实例化，其作用就是为了将来扩充该类
           		 2> 一个类不能同时被abstract和final修饰（以为final类不能被继承）。

                 3> 如果一个类包含抽象方法，该类必须声明为抽象类

                 4> 抽象类可以包含抽象方法和非抽象方法

                 5> 抽象类可以不包含抽象方法，但这样定义抽象类也就没任何意义了

 抽象方法：1> 抽象方法没有方法体

                   2> 抽象方法不能被声明为final（因final方法不能修改）和static

11.this关键字

成员变量、类变量、局部变量的区别：

成员变量、类变量、局部变量===>成员变量（实例变量）、（static）静态变量和局部变量的区别

成员变量和类变量

成员变量（实例变量）：定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量（静态变量）：声明在类中，方法体之外，但必须声明为static类型。static不能修饰局部变量

static修饰符，用于修饰成员(成员变量和成员函数)。

static静态方法只能访问静态成员，不可以访问非静态成员。静态方法在加载时，优先于对象存在，故而没有办法访问对象中的成员。
静态方法中不能使用this，super关键字。
因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

局部变量储存在栈内存：存储速度快，作用域用满释放而回收，可存储基本类型和引用变量，可通过引用变量调用堆内存中的内容；成员变量在堆内存，垃圾回收机制，类变量储存在方法区中

一、类变量和实例变量的区别

1、两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象的回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

3、别名不同

成员变量也称为实例变量。

静态变量也称为类变量。

4、数据存储位置不同

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

方法区

保存在着被加载过的每一个类的信息；这些信息由类加载器在加载类的时候，从类的源文件中抽取出来；static变量信息也保存在方法区中；

可以看做是将类（Class）的元数据，保存在方法区里；

方法区是线程共享的；当有多个线程都用到一个类的时候，而这个类还未被加载，则应该只有一个线程去加载类，让其他线程等待；

方法区的大小不必是固定的，jvm可以根据应用的需要动态调整。jvm也可以允许用户和程序指定方法区的初始大小，最小和最大限制；

方法区同样存在垃圾收集，因为通过用户定义的类加载器可以动态扩展Java程序，这样可能会导致一些类，不再被使用，变为垃圾。这时候需要进行垃圾清理。

final类变量（不存储在这里）

由于final的不可改变性，因此，final类变量的值在编译期间，就被确定了，因此被保存在类的常量池里面，然后在加载类的时候，复制进方法区的运行时常量池里面 ；final类变量存储在运行时常量池里面，每一个使用它的类保存着一个对其的引用；

class常量池、字符串常量池和运行时常量池的区别

二、类变量和实例变量的区别

​ 1、成员变量：

• 所属于对象，也称为实例变量

• 存在于堆内存中

• 随着对象创建而存在。随着对象被回收而消失

• 成员变量只能被对象所调用

  2、静态变量（类变量）

• 所属于类。所以也称为类变量

• 存在于方法区中

• 随着类的加载而存在。随着类的消失而消失。优先于对象存在

• 静态变量可以被对象调用，也可以被类名调用

  三、类变量和实例变量的区别

  

  PS：类变量是指一个类的变量，通常为静态变量，而实例变量通常是动态的，区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的也是改变后的结果；而实例变量容则属对象私有，某一个对象将其值改变，不影响其他对象。

  类变量：对象共有；成员变量（实例变量）：对象私有

成员变量和局部变量

  成员变量：
      1、成员变量定义在类中，在整个类中都可以被访问。

      2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

      3、成员变量有默认初始化值。

  局部变量：

      1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

      2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

      3、局部变量没有默认初始化值 

  在使用变量时需要遵循的原则为：就近原则

  首先在局部范围找，有就使用；接着在成员位置找。

其他扩展

封装可以实现变量的限制,包可以避免类冲突

有参构造时先写一个无参构造·

方法写类里面 功能写方法 里

属性和方法，类是对象的抽象 对象是类的实例化

方法名（）{}

文件结构（不考）

实参形参

实参：可以是常量、变量、表达式、类 有确定的值

形参：方法调用时用于接受实参值的变量

重载重写

*重载(Overload)：* 方法名相同，参数类型个数不同（发生同一个类） （1）Overloading是一个类中多态性的一种表现，让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。 （2）重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同，也可以不相同。无法以返回型别作为重载函数的区分标准。

*重写（Override)😗 子类对父类的更新覆盖（全部都相同，方法体不同）（父子类中） （1） 父类与子类之间的多态性，对父类的函数进行重新定义。即在子类中定义某方法与其父类有相同的名称和参数。 （2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

构造器 构造器特点和作用（this super-当前的父类）概念

用于创建对象并初始化对象属性的方法，叫“构造方法”，也叫“构造器”

面向过程 面向对象

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

什么是方法/设计原则/定义/void无返回值类型

封装继承多态理解并解释（简答题）//为什么

修饰符的范围

基础性也复习

this关键字 什么时候必须加this（学一个知识点就深入学完）

参数的传递：参数（数值型、字符串型、对象）放在方法的括号内传递，因为调用方法并传递参数时，参数其实就是方法的自变量。

new的使用原因：

匿名对象：不用定义对象的引用变量而直接来调用该对象的方法

​ 如：正常定义对象的引用变量 Fish fish = new Fish(); fish.move();

​ 匿名对象调用 new Fish().move();

匿名内部类：

抽象类、抽象方法

抽象类只能由派生的子类来创建对象 abstract修饰的

接口是抽象方法的集合，但不用abstrac修饰

传入图片两种方法

1. setIcon+alt+/（IamageIo.re+alt+/(tiis.get…(""))） io流读取图片

1. new对象传入图片

== 与 equals的区别

**线程的实现方法：**1.实现Runnable接口； 2.继承Thread类。 3.实现callable接口

内部类

匿名内部类

多态的体现

同一个事件发生在不同的对象上会产生不同的结果。

指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

多态存在的三个必要条件

• 要有继承；
• 要有重写；
• 父类引用指向子类对象。

泛型T代表 泛型将基本数据类型 int double char

​ 自动包装成 Integer Double Character

多用组合少用继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dGbaQ8KH-1646967432515)(F:\T笔记\Typora\笔记\java阶段\有道云笔记\qqB4B3F780E4959F67EC56B40DB99884EA\799edeb31795448687f08a43407886ff-07_17-38-48.png)]

for循环的执行顺序

下面就让我们一起来分析一下：

for(表达式1; 表达式2; 表达式3) {
     表达式4;
}

第一次循环：首先回去执行表达式1对变量进行初始化，之后去执行表达式2进行判断，是否符合表达式2的条件，如果符合，去执行表达式4，执行完表达式4，去执行表达式3（一般是对变量的加减操作）。

第一次循环：首先回去执行表达式1对变量进行初始化，之后去执行表达式2进行判断，是否符合表达式2的条件，如果符合，去执行表达式4，执行完表达式4，去执行表达式3（一般是对变量的加减操作）。

第二次循环：首先判断表达式2是否成立，如果成立，则去执行表达式4，之后去执行表达式3,。

数组和集合：

1. 数组可以存储基本数据类型，也可以存储引用数据类型，集合只能存储引用数据类型。

2. 数组是固定长度的，集合的长度是可变的。

3. 数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。

//=================================

this super static

this当前类调用方法的对象

static同类一起加载，因此不能用this

jdk、jre、jvm

JDK（java development kit）
JDK是Java开发工具包，是整个Java的核心，包括了Java运行环境JRE、Java工具和Java基础类库。

JRE（ java runtime environment）
JRE是java的运行环境，包含JVM标准实现及Java核心类库。

JVM（java virtual machine）
JVM是java虚拟机，是整个java实现跨平台的最核心的部分，能够运行以Java语言写作的软件程序。

三者的关系

JDK=JRE+其他

JRE=JVM+其他

JDK安装目录结构解析

强制转换总结：

1 字符串转换成数据

字符串转换成整数：

String MyNumber ="1234";
int MyInt = Integer.parseInt(MyNumber);

字符串转换成byte, short, int, float, double, long等数据类型，可以分别参考Byte, Short, Integer, Float, Double, Long类的parseXXX方法。

2 数据转换成字符串

整数转换成字符串：

int MyInt = 1234;
String MyString = "" + MyInt;

其它数据类型可以利用同样的方法转换成字符串。

3 十进制到其他进制的转换

十进制整数转换成二进制整数，返回结果是一个字符串：
Integer.toBinaryString(int i);
Integer和Long提供了toBinaryString, toHexString和toOctalString方法，可以方便的将数据转换成二进制、十六进制和八进制字符串。功能更加强大的是其toString(int/long i, int radix)方法，可以将一个十进制数转换成任意进制的字符串形式。
byte, short, float和double等数据类型，可以利用Integer或者是Long的toBinaryString, toHexString, to OctalString和toString方法转换成其他进制的字符串形式。

4 其它进制到十进制的转换

五进制字符串14414转换成十进制整数，结果是1234：

System.out.println(Integer.valueOf("14414", 5);

Integer和Long提供的valueOf(String source, int radix)方法，可以将任意进制的字符串转换成十进制数据。

5 整数到字节数组的转换

?

public` `static` `byte` `[] toByteArray(` `int` `number){``  ` `int` `temp = number;``  ` `byte` `[] b=` `new` `byte` `[` `4` `];``  ` `for` `(` `int` `i = b.length - ` `1` `; i > -` `1` `; i--)``  ` `{``   ` `b[i] = ` `new` `Integer(temp & ` `0xff` `).byteValue();``   ` `temp = temp >> ` `8` `;``  ` `}``  ` `return` `b;``}

6 字节数组到整数的转换

 1 public static int toInteger(byte[] b){
 2    int s = 0;
 3    for (int i = 0; i < 3; i++)
 4    {
 5       if (b[i] > 0)
 6       s = s + b[i];
 7    } else {
 8       s = s + 256 + b[i];
 9       s = s * 256;
10    }
11    if (b[3] > 0)
12    s = s + b[3];
13    else
14    s = s + 256 + b[3];
15    return s;
16 }

7 短整数与字节数组之间的相互转换

short与int之间的区别在于short是两个字节的，而int是四个字节的。因此，只需要将5 与6 中的范例程序小做改动，即可实现短整数与字节数组之间的相互转换。

8 字节数组转换成双精度浮点数

 1 public double toDouble(byte[] b){
 2    long l = 0;
 3    Double D = new Double(0.0);
 4    l = b[0];
 5    l |= ((long)b[1]<<8);
 6    l |= ((long)b[2]<<16);
 7    l |= ((long)b[3]<<24);
 8    l |= ((long)b[4]<<32);
 9    l |= ((long)b[5]<<40);
10    l |= ((long)b[6]<<48);
11    l |= ((long)b[7]<<56);
12    return D.longBitsToDouble(l);
13 }

9 布尔类型转换成字符串

第一种方法是：

1 boolean bool = true;
2 String s = new Boolean(bool).toString();//将bool利用对象封装器转化为对象
3 s.equals("true");

第二种方法是：

1 boolean bool = true;
2 String s = String.valueOf( bool );

首先，从代码长度上讲第二种方法明显要比第一种方法简洁；其次，第一种方法在转化过程中多引入了一个完全没有必要的对象，因此，相对第二种方法来说这就造成了内存空间的浪费，大大减慢了运行速度。所以，推荐使用第二种方法。

10 数字类型与数字类对象之间的转换

 1 byte b = 169;
 2 Byte bo = new Byte( b );
 3 b = bo.byteValue();
 4 short t = 169;
 5 Short to = new Short( t );
 6 t = to.shortValue();
 7 int i = 169;
 8 Integer io = new Integer( i );
 9 i = io.intValue();
10 long l = 169;
11 Long lo = new Long( l );
12 l = lo.longValue();
13 float f = 169f;
14 Float fo = new Float( f );
15 f = fo.floatValue();
16 double d = 169f;
17 Double dObj = new Double( d );
18 d = dObj.doubleValue();
19 5.0 String 转 Integer
20 Integer in=new Integer(String s);
21 Integer in=new Integer(Integer.parseInt(String s));

5.1 String 转 int

1 int i = Integer.parseInt([String]); 或 i = Integer.parseInt([String],[int radix]);
2  int i = Integer.valueOf(my_str).intValue();

5.2 如何将整数 int 转换成字串 String ?

A. 有叁种方法:

1 String s = String.valueOf(i);
2 String s = Integer.toString(i);
3 String s = "" + i;

注: Double, Float, Long 转成字串的方法大同小异.

5.3 String 转 Date

将String转换为Date：
 String s="2007-06-21 10:50:50";
SimpleDateFormat FormatDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date date = FormatDate.parse(s);

//转成Date将Date转换为String String.valueOf(date);

Java如何获得系统时间，

想要获得系统时间，不要日期，只要时间
Date now = new Date(); //Date（）是java.util.Date类的构造方法
DateFormat d = DateFormat.getTimeInstance(); //getTimeInstance()获得的是不带日期的系统时间
String str = d.format(now); System.out.println("Today is " + str);//输出
注：1.Date now = new Date(); 这句中的Date（）是java.util.Date类的构造方法，而不是java.sql里的类，所以要在前面加上import java.util.Date;而不是 import java.sql.Date;这里曾经因为犯了这种低级错误而导致编译出错。

ndexOf()的两种用法和实现功能：

1、 indexOf(String str): 返回指定字符str在字符串中（方法调用者）第一次出现处的起始索引，如果此字符串中没有这样的字符，则返回 -1。
2、indexOf(String str, int index): 返回从 index 位置开始查找指定字符str在字符串中第一次出现处的起始索引，如果此字符串中没有这样的字符，则返回 -1。

举例说明：

String str = “01234567890123456789”;
System.out.println(str.indexOf(“123”));
System.out.println(str.indexOf(“123”,5));
上面程序的结果为1和11。

第1个输出函数中的indexOf()方法只有一个参数，故返回123在str中第一次出现处的索引，为1；

第1个输出函数中的indexOf()方法有两个参数，第一个参数为要查找的字符串123，

第2个参数为从第5所以位置处开始查找，故只能查找到str中的第2个123，返回其出现的起始索引，为11。

Math()的常见使用

Math:用于数学运算的类
成员变量：
public static final double PI
public static final double E
成员方法：
public static int abs(int a)绝对值
public static double ceil(double a)向上取整
publuc static double floor(double a)向下取整
public static int max(int a,int b)最大值
publuc static double pow(double a,double b)a的b次幂
publuc static double random()随机数
publuc static int round(float a)四舍五入
publuc static double sqrt(double a)正平方根

java字节和字符的理解

一、字节的概念

​ 1、计算机中的数据都是以二进制的形式进行存储和交换的，字节本质就是二进制，因此字节是最基本的储存单位

2、一个字节本质就是8位二进制，因此1个字节最小的值是0，最大的值是11111111，转换十进制后就是255

二、字符概念

​ 字符就是人们使用的记号，抽象意义的符号而已，如“1”，“中”，“&”等这些记号代表不同的意思

三、字节和字符的关系

1、字节是计算机的基本储存单位，字符是人们为了便于记录而使用的记号等，字符在计算机中是由字节存储的

2、 字符是根据字符集指定的编码标准而变成字节存储的

四、字符集和编码

​ 字符集：字符集合，包含众多字符

​ 编码：规定字符集中的字符由一个字节还是多个字节存储，由哪些字节存储等

五、字符集阶段性

​ 系统阶段：ASCII(美国信息交换标准代码)是最早推出的字符集，共有128种字符，其使用7位二进制来代表ASCII字符，最高的一位二进制用作奇偶校验，128种字符中只有最基本的英文字母和一些符号而已

    本地化阶段：ANSI编码是指为了使计算机支持更多语言，而使用二个字节存储一个字符的字符集。但是这样只是各个地方为了自己支持更多语言使用的标准，因此会出现同一个字符不同的字节存储的情况，不利于国际交流

    国际化阶段：UNICODE字符集，为各种语言中的每一个字符设定了统一并且唯一的数字编号,以满足跨语言、跨平台进行文本转换、处理的要求

    现在使用最多的就是UNiCODE字符集

针对UNICODE字符集出现了众多的编码标准，有我们常知的“utf-8”，“utf-16”,"iso-8859-1"等。现在程序中使用最多的就是“utf-8”编码标准，我们实际上没有必要去深究每一种编码具体把某一个字符编码成了哪几个字节,我们只需要知道“编码”的概念就是把“字符”转化成“字节”就可以了

六、自我总结

字节是计算机的基本储存单位，字符就是计算机中特殊的符号

数组

package For_05;

import java.util.Arrays;

import javax.swing.Box.Filler;

public class demo_03 {
public static void main(String[] args) {
	int [] a = {2,8,5,3,4,7,5,2,1};
	int [] b = new int [] {2,8,5,3,4,7,5,2,1};
	int [] c = new int[6];
	int mid=0;
//	for(int i=0,j=a.length-1;i<a.length/2;i++,j--) {
//		mid=a[i];
//		a[i]=a[j];
//		a[j]=mid;
//		
//	}
//	System.out.println(Arrays.toString(a));
	for(int  i:a) {
		System.out.print(i);
	}
	}
	}

	
	
/*	for(int i=0;i<a.length;i++) {
		System.out.println(a[i]);
	}
//一
	for(int i:a) {
		System.out.println(i);
	}
//二
	System.out.println(
);
//	三
//	demo_01.printarray(a);
//四
*/	//遍历数组
	
	
	
/*	int mid =0;
	for(int i=0;i<a.length -1;i++) {
		for(int j=0;j<a.length-1-i;j++) {
			if(a[j]>a[j+1]) {
				mid=a[j+1];
//				a[j]=a[j+1];
				a[j+1]=a[j];
				a[j]=mid;
			}
		}
	
//	}System.out.println(a[i]);
		
}System.out.println(Arrays.toString(a));
}
}


/*	for (int i = 0;i < a.length -1;++i)
	{
		//将第一个数从头比较到最后一个数
		for (int j = 0;j < a.length-1-i;++j)
		{
			//若是后面的数比前面的数大，就进行交换
			if (a[j] < a[j + 1])
			{
				int b = a[j];
				a[j] = a[j + 1];
				a[j + 1] = b;
			}
		}
		System.out.println(a[i]);
}
}
}*/		//数组排序/冒号排序

/*
Arrays.fill(a, 3);
System.out.println(Arrays.toString(a));
//数组填充
 */
//}
//}
	
	
/*	
	int sum=0;
//	for(int i=0;i<a.length;i++) {//36为什么
	for( int i:a) {   //37
		 sum +=i;
	}	
	System.out.println(sum);
	}
}*/   //求和