java学习笔记

最新推荐文章于 2024-07-15 22:27:12 发布

漫步星云

最新推荐文章于 2024-07-15 22:27:12 发布

阅读量265

点赞数

分类专栏： java语法文章标签： java笔记 java 经验分享

本文链接：https://blog.csdn.net/weixin_44062302/article/details/102926132

版权

java语法专栏收录该内容

4 篇文章 0 订阅

订阅专栏

short s = 10;

s = s + 5; //会造成编译异常， s 自动类型转化成int

s = (short)(s + 5)
s += 5
这两种情况则，并不会造成编译异常。

对于byte, short, int, long 而言，创建数组之后，默认的值为0；

对于float， double而言，创建数组之后，默认值是0.0

对于char类型而言，默认是空格

对于引用类型而言，默认是false

对于引用类型构成的数组，以String为例默认的值是null

内存的组成： 1.栈, (stack) 局部变量，对象的引用2.堆，(heap)new出来的东西 3.方法区， 4，静态域

数组一旦初始化，他的长度是不可变的。

如果想扩容的话，必须重新新建一个数组，然后将原来的数组的元素的值赋值给新建的数组，并将新添入的数的值追加到原来的数组的后面。

二维数组的长度是数组的行数，二维数组元素的值是二维数组每个元素的值。也就是每行的列数。

二维数组的异常

1.数组下标越界的异常。

2.空指针的异常。

第一种：
boolean []b = new boolean[3];
b = null;
System.out.println(b[0]);
会引起空指针异常。

第二种：
String [] str = new String[4];
System.out.println(str[3].toString());

第三种：
int[][]j = new int [3][];
j[2][0] = 2;

排序算法： 1.插入排序，（选择排序，堆排序） 2.交换排序，（冒泡排序，快速排序） 3. 选择排序，4. 归并排序

java中可以直接使用Arrays.sort(arr)对数组进行排序。这个排序的核心思想使用的是快速排序。

疑问：为什么for (int i = 0; j = 0; j < arr.length; i++, j++)会进行报错

面向对象的三条主线：

1.类几类的构成成分：属性方法构造器代码块内部类

2.面向对象编程的特征：封装性，继承性，多态性，（抽象性）

3.其他的关键字： this, super, package, import, static, final, abstract, interface…

OOP面向对象；POP面向过程；面向对象是相对于面向过程而言的，面向过程强调的是功能性为。面向对象，将功能风装进对象，强调具备了功能的对象。

类中只能有方法，不能在方法之外在存在格外的语句。

方法的重载（overload)

要求： 1.同一个类中，2.方法的名必须相同，3.方法的参数列列表不同（参数的个数不同，参数的类型不同）；

补充：方法的重载和方法的返回值类型无关，参数列表和函数名相同的时候，函数不能进行重载；

对于高级编程语言分为好几代，对于第三代高级编程语言，分为两种，分别是面向过程，和面向对象。

面向对象编程的思想的落地法则一：

设计并创建类以及类的成分。
实例化累的对象。
通过对象属性或对象方法的形式完成某项功能。
类的初始化的内存解析。1栈stack, 2堆heap3.方法区4.静态域：声明为static的变量。（学会创建基本对象在内存中的运行）。
方法/构造器的重载。

匿名类对象的建立，new circle.show()

当我们只需要一次调用类的对象的时候，我们就可以考虑使用匿名的方式创建类的对象；
特点：创建的匿名的类的对象只能够调用一次。

可变个数的形参的方法；

对于方法的形参，数据类型。。。形参名
可变个数的形参的方法与同名的方法之间构成重载。
eg:publicvoid sayHello(String … args)
参数从0到无穷多个。
使用可变多个数形参的方法与方法的形参使用数组是一致的。
若方法中存在可变个数的形参，那么一定要声明在方法的形参的最后。

java中的参数传递机制，值传递机制。

形参是基本的数据类型，将实参的值传递给形参的基本数据类型的变量。
形参是引用数据类型的。实参的引用类型的变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用。

封装和隐藏

private修饰的属性只能在本类中被调用，出了这个类就不能被调用。

面向对象的特征：封装隐藏，

（封装的思想，1.将类中的属性私有化, 2.定义相应的公共方法设置和获取（setter & getter）类的属性。）

目的：隐藏一个类中不需要对外部提供的实现细节；使用者只能够通过事先定制好的方法来访问数据，可以方便的加入控制逻辑，限制对属性的不合理操作；便于修改，增强代码的可维护性。

throw new runTimeException

类的第三个成员，构造器(constructor 构造方法)；作用：创建类。如果没有声明构造器·，则默认提供一个空参的构造器；一旦显示定义类的构造器，那么默认的构造器就不在提供；

四种权限修饰符： 1.public, 2.protected. 3.缺省， 4.private;

修饰类的只能是public或者default（缺省）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0Tvf2OEp-1572964999174)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1566747263442.png)]

this可以用来显示的调用当前类中的重载的指定的构造器。

在本类的构造器当中调用其他重载的指定的构造器，1. 必须声明在首行；2. 若一个类中有n个构造只能有（n-1)个构造器可以使用this(参数)

package: 声明源文件所在的包，写在程序的第一行；每“ .”一次，表示一层文件目录；包含要大小写；

import：显示导入指定包下的类或者接口，写在包的声明和源文件之间；如果需要引入多个类或者接口，那么就并列写出，如果导入的是lang（language）包下的，如System String Math;等，就不需要显示的声明；

如何导入同名类的导入：如，在util包和sql包下同时存在Data类。通过

java.sql.Data d = new java.sql.Data(55555L);

import static 表示导入指定类的static的属性或者方法；（JDK 1.5新加入）

import static java.lang.System.*;
out.println("helloworld");

java.lang.*只能导入lang包下的所有类和接口，不能导入lang的子包下的类或者接口；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LEVVgS9V-1572964999174)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1566836102373.png)]

JavaBean:** 是一种java语言写成的可重用组件，（他符合如下的标准的java类，类是公共的；有一个无参数的公共构造器；有属性，并且有对应的get, set方法；）

用户可以使用javaBean将功能，处理，值，数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发这可以通过内部的jsp页面， servlet, 其他javaBean, applet程序或者应用来使用这些对象，用户可以认为javaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

UML类图：

继承：方法的重写（override）四种访问权限修饰符，super, 子类对象实例化过程

class A extends Person 让a继承person，子类继承父类之后父类中声明的方法属性，子类就能获取的到。

父类有叫做基类（superClass）

当父类中有私有的属性或者方法时，子类同样可以获得到，只是由于封装性的设计，使子类不能够直接的调用。

一个类只能继承一个父类，反之，一个父类可以有多个子类；子父累的概念是相对的。

子类从父类中继承的方法如果不适合子类，子类可以对方法进行重写（overrider）。

要求子类方法的 “返回值类型方法名（参数列表）”与父类的方法一样。
子类方法的修饰符不能小于父类方法的修饰符。
若父类方法抛出异常，那么子类方法抛出的异常类型不能大于父类的。
子父类的方法必须同为static或同为非static的。

super关键字

java类中使用super来调用父类中的指定操作
super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造方法中调用父类的构造器，（当调用父类的构造器的时候，规则和this调用本类的构造器是相同的）当不显示的调用this(形参列表)， super(形参列表)中的任意一个，使用的都是父类的空参构造器。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LLZNnfXC-1572964999174)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1566903211086.png)]
当子类重写父类的方法以后，在子类中如果想显示的调用父类的被重写的方法，可以使用“super.方法”进行调用。

当字父类中出现同名成员时，可以用super进行区分，super的追溯不仅限于直接父类，this代表本类对象的引用，super代表父类的内存空间的标识

建议：设计一个类的时候，尽量提供一个空参的构造器。

所有类继承的根父类叫做object

多态性

使用多态性的条件：(1.含有子类对父类方法的继承，2.子类中有对父类方法的重写 )

子类对象的多态性，并不使用与属性。

多态性是指一个事物的多种表现形式，方法的重载和方法的重写属于多态性的一部分。

对象的多态性，父类的引用指向子类对象；

虚拟方法调用，通过父类的引用指向子类的对象实体，当调用方法时，实际执行的是子类重写父类的方法。

格式：对象 a instanceof 类A，判断对象是否是类A的一个实例，是的话，返回TRUE，不是的话，返回false,若a是类A的实例，那么a也一定是类A父类的实例； woman w1 = (woman) p1 将w1（

person p1 = new woman()）强制类型转化为woman类；

equals（java.lang.Object）

equals是最终根父类Object的方法，1.基本数据类型，判断基本数据类型的值是否相等，数据类型可以不同

2.引用数据类型，比较引用数据类型变量的地址值是否相等。

对于String, File, Date这些类重写Object类的equals()的方法，比两个“实体内容”是否完全相同。

要想自定义类使用equals比较两个类是否相等，需要在类中重写equals()方法。

toString()方法，

1.当我们打印一个对象的引用的时候，默认调用的就是这个对象的toString方法

2.当我们调用没有重写的Object中的toString()方法的时候，那么返回对象所在的类以及对应的堆空间对象实体的首地址值。

3.我们一般进行重写toString()方法的时候，tostring一般写成return “Person:name = ” + name + “age” + age;

4.像String，包装类，File类，Date类等，已经实现了对toString()方法的重写。

包装类

针对八种基本定义相应的引用类型 – 包装类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RJo5WCqM-1572964999174)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568034523203.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yog7jF7W-1572964999175)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1567261232845.png)]

Junit单元测试类：

1.当前工程下-邮件build path-add librarise -Junit4

2.在主类中，创建一个空参的无返回值的方法， (如， public void test1())用于代码的测试，方法上声明，@Test

3.导入 import org.junit.Test;

4.在test1()方法中，进行代码的编写。

5.测试，双击方法名，右键run as-junit Test即可。

包装类 ==》基本数据类型：调用包装类XXX的Xxxvalue（）方法 intValue();

自动装箱方法， Integer i = 12; int j = i;

基本数据类型，包装类 -->String类：调用String类的重载的valueOf(xxx x)方法

i + “” // String.valueOf(i)

String类 --> 基本数据类型，包装类：调用包装类的parseXxx方法，如Integer.parseInt(str2)

类变量（由static修饰）

通过类创建的所有对象共用这一个属性，当一个对象对属性进行修改，会导致其他对象对此属性的调用改变，，类变量的加载失要早于对象的，当对象创建以后，可以通过"对象.类变量"进行使用，而这对于"类.实例变量"是行不通的。类变量在内存上存储在静态域中。

static修饰的类方法：1.随着类的加载为加载，2.独立的一块内存存储。3.静态的方法中，只能调用静态的属性或者方法。(因为(static的属性，方法，代码块，内部类生命周期早)静态的属性或者方法加载的比较早，回收的也晚于非静态的)，而非静态的是可以调用静态的方法。

静态的方法内是不能够使用this或者super关键字的。

设计模式，设计模式是在大量的实践中总结和理论化之后优选的代码结构和编程风格。

目前一共有23种设计模式。

单例的设计模式：解决的问题，使得一个类只能够创建一个对象。

代码块：又叫做初始化块，代码块使用修饰符的话只能使用static，

静态代码块：随着类的加载，而且只被加载一次，静态代码块执行早于非静态代码块，多个静态代码块之间按照顺序执行，里面可以有输出语句，

非静态代码块，可以对类的属性进行初始化操作，里面可以有输出语句，一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行，每创建一个类的对象，非静态代码块就加载一次，非静态代码块执行早于构造器

属性初始化，默认初始化，显示的代码初始化或者代码块的初始化(此处两个结构顺序执行)，构造器，通过方法进行修改。

final:最终的，可以用来修饰类，属性，方法。

final修饰类，这个类就不能被继承，如，String类，StringBuffer类，System类

final修饰方法，这个方法不能够被重写。eg: public final void method() {}，Object类的getClass()

final修饰属性，此属性就是一个常量，习惯用大写字母表示。不能再被赋值，不能使用默认初始化，可以，显示赋值，代码块赋值，构造器赋值。

注意：在进行方法调用的时候，不能进行常量的赋值，因为对象的方法要对对象进行调用，对象必须进行初始化完成。

变量使用static final 修饰，就是全局常量。

于finally finalize()进行区分

抽象类（abstract class）

继承的层次中，随着继承层次的一个个新的子类的定义，类变得越来越具体，而父类更一般，更通用，类的设计应该保证父类和子类能够共享特征，有时候需要将一个父类设计的非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

abstract:抽象的，可以用来修饰类，方法，

1.修饰类是抽象类(不可以被实例化，抽象类有构造器（凡是类都有构造器），抽象方法所在的类一定是抽象类)，抽象类中可以没有抽象方法

2.修饰方法是抽象方法，抽象类可以没有实体方法，格式：public abstract void eat();抽象方法只保留方法的功能，而具体的执行则交给子类去执行；如果子类继承抽象类，没有重写所有的抽象方法，就意味着此类中任然存在这抽象的方法，则此类就必须声明成为抽象的。

abstract 不能用来修饰属性和构造器，方法不能和private,final,static同时使用。

抽象类体现的是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行改造，但子类总体上会保留抽象类的行为方式。（功能内部一部分实现是确定的，一部分的实现是不确定的，我们可以把不确定的部分暴露出去，让子类去实现）编写一个抽象父类，留给子类多个通用的方法让子类实现，就是一种模板模式。

接口（interface）

可以看成特殊类，是抽样方法和常量值的定义集合。接口没有构造器，不能包含变量，一般的方法；定义的就是一种功能，这种功能可以被类所实习(implements)（本质是一种特殊的抽象类，这种抽象类只含有常量和方法的定义，没有常量和方法的实现）

有时候必须从几个类中派生出一个子类，继承他们所有的方法和属性，当时java不支持多继承，有了借口可以实现多继承的效果

接口是和类并行的一个概念。定义interface AA{}

class subclass implements interfaceA {}

接口之间任然是继承但额关系，（可以实现多继承。）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-znNWNohf-1572964999176)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1567595608066.png)]

工厂方法的设计模式，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f7Z0PjWw-1572964999176)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1567596287892.png)] 代理模式；为其他对象提供一种代理方法可以控制对象。

常用数据库：MySQL:小型免费的数据库，Oracle:保密性强适合银行企业的大型收费的数据库，DB2：由IBM公司提供的数据库，SQLserver:由微软公司提供的数据库。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yxxl1qqV-1572964999176)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1567603511734.png)]

内部类

掌(1.如何创建一个内部类，2.如何区分调用外部类，内部类(尤其是变量名重名的时候)，3.局部内部类的使用)

java中允许一个类的定义在另一个的类的内部，前者称为内部类，后者称为外部类。

inner class 一般用在定义它的类或者语句块之内，在外部引用它的时候必须给出完整的名称

inner class 可以使用外部类的私有数据，但是外部类想要访问内部类中的成员需要：内部类.成员/内部类.内部类对象.成员。（成员内部类(static 成员内部类和非static成员内部类)/局部内部类(无修饰符)/匿名内部类）

内部类中的局部类

常常使用一个方法，是其返回值为某个类或者接口的对象，而这个类或者接口在方法的内部创建；

返回一个匿名的类，

java异常：

java.lang.Throwable直接从lang包下的Object直接继承，它下面有两个子类，Error和Exception

Exception又分为，编译时异常和运行时候的异常。

在java语言中，将程序执行中发生的不正常情况称为“异常”；(开发过程中的语法错误或者逻辑错误不是异常)

1.Error: java虚拟机无法解决的严重问题，如JVM系统内部错误，资源耗尽等严重情况。一般不编写针对性的代码进行处理。不进行显示的处理。

2.Exception: 其他因编程错误或者偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理

分为运行时异常(RuntiemException) ArrayIndexOutOfBoundsException/NullPointException/ArithmeticException/ClassCaseException

和非运行时的异常(编译时候的异常)。例如

空指针访问；
试图读取不存在的文件；
网络连接中断；

try{} catch () {} finally{}

当有多个catch语句的时候，try中抛出的异常类对象从上往下执行匹配catch中的异常类型，一旦满足，就执行catch中的代码，执行完之后，就跳出其余的多条catch语句。

异常处理：1.手动在catch语句中使用System将异常进行打出，2.将执行的每一步都给显示出来e.printStackTrace()3.含有返回值的e.getMessage 4.如果异常进行处理了，那么其后的代码继续执行；

5.如果catch中的多个异常是 “并列” 关系，顺序问题无所谓；如果是“包含”关系，必须将子类放在父类的上面进行处理，否则报错！

finallly中存放的是一定会被执行的代码，不管try中，catch中是否任然有异常没有被处理，以及是否

try - catch语句是可以相互进行嵌套的。

运行时候的异常可以不显示的进行处理；编译的异常，必须要进行显示的处理。

throw new RuntimeException(“传入的数据类型有误”);

如何自定义异常

自定义的异常类继承现有的异常类
提供一个序列号，提供几个重载的构造器

集合

存储对象：1.数组，2.集合；

数组存储对象的特点，一旦创建，他的长度是不能改变的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TRVfwrfs-1572964999176)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568041440801.png)]

Collection:接口：

Set: 元素无序，不可重复的集合；Set中常用的方法都是在Collection下定义的。(真正的无序性指的是元素在底层存储的位置是无序的)

HashSet(主要实现类), LinkedHashSet(使用链表维护了一个添加进集合的顺序，当我们遍历L时，按着添加时的顺序，不过照样是无序的), TreeSet

List: 元素有序，可重复的集合； ArrayList(使用数组实现), LinkedList(使用链表实现), Vector(非常古老的方法，但是线程安全)

Map:接口：

具有映射关系 “ key - value” 对的集合；HashMap, LinkedHashMap, TreeMap, HashTable(子类，properties)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jCu6zaw0-1572964999177)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568093221060.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XPdzbf1P-1572964999177)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568101879819.png)]

map

map和Collection并列存在，用于保存具有映射关系的数据key - value

map中key用set来存放，不允许重复，即用一个Map对象对应的类，要重写hashCode(),和equal方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ay8o192m-1572964999177)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568523115933.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MBWqhg86-1572964999177)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568523372890.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uUiXgblO-1572964999177)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568528050980.png)]

Hashtable是一个古老的Map实现类，线程安全，

和hashmap不同，不允许使用null作为key和value值
和HashMap相同，不能保证其中key - value对的顺序
Hashtable判断两个key相等，两个value相等的标准，和hashMap一致。

对应集合的有一个Collection的工具类，Collections是一个操作Set,List, Map等集合的工具类，

Collection中提供了一系列静态的方法对集合元素进行排序，查询和修改等操作，还提供了对集合对象设置不可变，对集合对象实现同步控制等方法。

1.reverse(List), 2.shuffle(List)对List集合元素进行随机排序, 3.sort(List)根据元素的自然顺序按照升序进行排列， 4.sort(List, Co,parator) 根据指定的Comparator产生的顺序对List集合元素进行排序。 5. swap(List, int, int ):将指定list集合中的i处元素和j处元素进行交换。6.max(Collection)，根据元素的自然排序，返回给定集合中最大的。 7.max(Collection, Comparator), 根据Comparator指定的顺序，返回， 8.min(Collection), 9 min(Collection, Comparator), 10 .int frequency(Collection, Object ), 返回指定集合中指定的元素出现的次数。 11. void copy(Collection l1, Collection l2),使用这个方法如果l1当中的空间小余l2中的空间，这个方法就会报错。解决方案如下：List list1 = Arrays.asList(new Object[list.size()]);12.boolean replaceAll(List list, Object oldVal, Object new Val); 13. synchronizedList通过这个方法来保证list的线程安全，因此不建议使用Vector,和Hashtable

Enumeration接口是Iterator迭代器的一个古老的版本，

Enumeration  stringEnum = new StringTokenizer("a-b * c-d-e-g*",  "-");
	while(stringEnum.hasMoreElements()) {
        Object obj = stringEnum.nextElement();
        System.out.println(obj);
	}

泛型（generics）静态方法中不能使用泛型的声明，catch中也不能使用泛型的声明

1.没有使用泛型，任何的Object以及他的子类对象都可以添加进来，

2.强制转化为int的时候，可能会ClassCastException的异常。

在集合中使用泛型：List list = new ArrayList();

泛型的使用：1.在集合中使用泛型，2.自定义泛型，泛型接口，泛型方法 3.泛型和继承的关系，4. 通配符。

1.当时实例化泛型类的对象时，指明泛型类的类型，（指明之后，类中所有使用泛型的位置，都变成实例化中的泛型）

通配符List<?> list = null;

List list1 = new ArrayList ();

通配符 ？
//List<A>, List<B>....都是List<?>的子类
List<? extends Number> list1 = null;// ? extends A:可以放A的子类
List<Integer> list2 = null;
list1 = list2;
List<? super Number> list3 = null;// ？super A: 可以放A以及A的父类
List<Object> list4 = null;
list3 = list4;

当集合使用通配符的时候，使用put 方法只能想里面添加null元素。但是可以对集合内部的元素进行遍历。

枚举类

1.自定义

class Season {
	//提供类的属性
    private final String seasonName;
    private final String seasonDesc;
    //私有化构造器，声明为final的属性进行初始化。
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //公共方法进行调用
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    public static final Season SPRING = new Season("spring", "春暖花开");
	public static final Season SUMMER = new Season("summer", "夏日炎炎");
	public static final Season AUTUMN = new Season("autumn", "秋高气爽");
	public static final Season WINTER = new Season("winter", "白雪皑皑");
	
	@Override
	public String toString() {
        return "Season [seasonName " + seasonName + ",seasonDesc =" + seasonDesc +" ]";
	}
}

2.使用enum关键字定义

enum Season1 {
    SPRING("spring", "春暖花开")
    {//可以让不同的枚举类型的对象调用被重写的抽样方法，执行的效果不同，相当于让每一个对象重	  //方法。
        public void show() {
            System.out.println("春天在哪里");
        }
    }
    SUMMER("summer", "夏日炎炎"),
    AUTUMN("autumn", "秋高气爽”),
    WINTER("winter", "白雪皑皑");
           
    private final String seasonName;
    private final String seasonDesc;
           
    private Season(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
}

3.枚举方法：

1.values()：  返回一个枚举类型全部的内部成员，2.valueOf(String name) : 要求传入的形参name必须是枚举类对象的名字。否则回报java.lang.IllegaArgumentException异常。
Thread.State[] states = Thread.State.values();
for(int i = 0; i < states.length; i++)
    System.out.println(states[i]);

注解(Annotation)

Annotation 其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时候被读取，并执行相应的处理，通过使用Annotation,可以不改变原有的逻辑的情况下，在源文件中嵌入一些补充信息；
可以像修饰符一样被使用，可以用于修饰包，类，构造器，方法，成员变量，参数，局部变量的声明，这些信息别保存在Annotation的"name = value"对中。
Annnotataion能被用来为程序元素(类，方法，成员变量)设置元数据。

使用Annotation时要在他前面加上@符号，并把该Annotation当成一个修饰符使用，用来修饰它支持的程序元素。

基本注解：@Override: 限定重写父类方法，该注解只能用于方法 ,@Deprecated:用于表示某个程序元素(类，方法等)已经过时 ,@SuppressWarnings:抑制编译警告

自定义注解：

public @interface MyAnnotation {
    String value() default "hello";
}

对注解进行注解(元注解)：

Annotation用于修饰其他Annottaion的定义：Retention,(常用) Target(常用), Documented, Inherited

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dGz3Q1Fe-1572964999178)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568618580968.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-537OMbcV-1572964999179)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568619012207.png)]

Retention: SOURCE,  CLASS,  RUNTIME
Target:
Documented: javadoc
Inheri:

关于IO流：

java.io.File类的使用； IO原理以及流的分类;

文件流：FileInputStream / FileOutputStream / FileReader / FileWriter

缓冲流：BufferedInputStream / BufferedOutputStream / BufferedReader / BufferedWriter

转化流：InputStreamReader / OutputStreamWriter

标准输入输出流：

打印流：PrintStream / PrintWriter

数据流：DataInputStream / DataOutputStream

对象流：-----涉及到序列化，反序列化，ObjectInputStream / ObjectOutputStream

随机存取文件流：RandomAccessFile

java.io.File类

1.凡是与输入，输出相关的类，接口都定义在java.io包下
2.File 是一个类，可以有构造器创建其对象,此对象对应一个文件(.txt .avi.doc.ppt .mp3 .jpg) 或者文件目录
3.File类对象是与平台无关的。
4.File中的方法，仅涉及到如何创建，删除，重命名，等等。只要涉及文件内容的File是无能为力的，必须由io流宛城。
5.File类的对象常作为io流的具体类的构造器的形参。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ybfqpq7e-1572964999179)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568689921639.png)]

boolean b = file1.renameTo(file2);

file1.lastModified()最后一次修改的时间， 数据类型是long  可以用new Date()将它作为参数传进去，之后将会显示时间。   length将会显示长度。

createNewFile()，新建文件，

File file = new File("c:\\User\\xc\\desktop\\test");
if (!file1.exists()) {
    boolean b = file1.createNewFile();
}

mkDir创建目录，如果上级目录存在才能创建成功，mkDirs如果上层目录不存在，将上层的目录一起给创建。

listFiles()  :    File[] files = file.listFiles();
for(int i = 0 ; i < files.length; i++) {
    System.out.println(files[i].getName());
}
list()  :   String[] strs = files.list(); //打出文件名字
for(int i = 0; i < strs.length; i++) {
    System.out.println(file[i].getName());
}

流的分类

按照数据单位不同分成：字节流(8 bit), 字符流(16 bit);
按照数据流的流向不同分成：输入流，输出流；
按照流的角色分成：字节流，处理流；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4tx4f67S-1572964999179)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568710030588.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mwgMEmrB-1572964999179)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1568732659500.png)]

1.创建一个File类对象； 2.创建一个FileInputStream类的对象； 3.调用FileInputStream的方法，实现file文件的读取。4.read()读取文件的一个字节，当执行到文件结尾的时候，返回-1；5：因为文件是外部资源所以需要进行手动的关闭。

基类

InputStream, outputStream, Reader, Writer

节点流（文件流）阻塞式

字节流

FileInputStream 输入流，将文件中的字符输入程序。

File file = new File("hello.txt");
FileInputStream fis = new FileInputStream(file);
byte[] b = new byte[5];
int len;
while ((len = fis.read(b)) != -1) {
// for (int i = 0; i < len; i++) {
// System.out.print(b[i]);
// }
String str = new String(b, 0, len);
}

FileOutputStream 创建一个对象，表明写入的位置，输出的文件可以不存在，执行过程中，如果不存在，会自动创建，如果存在，会将原有的文件覆盖。

File file = new File("hello.txt");
fos = new FileOutputStream(file);
fos.write(new String("I love China I love the World").getBytes());

文件复制

File file1 = new File("C:\\Users\\xc\\Desktop\\1.jpg");
File file2 = new File("C:\\Users\\xc\\Desktop\\2.jpg");
fis = new FileInputStream(file1);
fos = new FileOutputStream(file2);
byte[] b = new byte[20];
int len;
while ((len = fis.read(b)) != -1) {
fos.write(b, 0, len);
}

字符流

FileReader, FileWriter两个类，使用方法和字节流的使用方法相同，处理的单位不同，字符流是用字符为基本单位的；

对于文本文件可以使用FileReader,和FileWriter来说处理，不能实现非文本文件的处理。

对于非文本文件只能使用FileInputStream, FileOutputStream.字节流进行处理。

缓冲流（处理流的一种）非阻塞式

BufferedInputStream, BufferedOutputStream flush () ,BufferedReader,(feadLine () ) BufferedWriter( flush （）)

FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);

转换流（处理流之二）

字节流中的数据都是字符时，转化成字符流操作更高。

InputStreamReader, OutputStreamWriter;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X1v1JELX-1572964999179)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1569490318823.png)]

ASCII：美国标准信息交换码。（使用一个字节的7位来表示）

ISO8859-1：拉丁码表。欧洲码表。（用一个字节的8位来表示）

GB2312：中国的中文编码表

GBK：中国的中文编码表升级，融合了更多的中文文字符号。

Unicode：国际标准码，融合了多种文字。（都有的文字都用两个字节表示，Java使用的就是Unicode）

UTF-8：最多用三个字节来表示一个字符。

打印流

PrintStream, PrintWriter

FileOutputSteam fos = new FileOutputStream(new File("print.txt"));
PrintStream ps = new PrintStream(fos, true);
if (ps != null) //把标准输出流（控制台输出）改成文件
	System.setOut(ps);
for (int i = 0; i <= 255; i++) {
    System.out.print((char) i);
    if (i%50 == 0)
    	System.out.printtln();
}
ps.close();

数据流(处理流)

用来处理*基本数据类型*，String,字节数组的数据：DataInputStream,DataOutputStream

对象流（处理流）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CVZaFwQ9-1572964999179)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1569995646168.png)]

ObjectInputStream, ObjectOutputStream

用于存储和读取对象的处理流，它的强大之处在于可以把java的对象写入到数据源中，也能把数据从数据源中还原回来。

序列化(Serialize):用ObjectOutputStream类将一个java对象写入IO流中，

反序列化（Deserialize):用ObjectInputStream类从IO流中恢复该java对象。

ObjectOutputStream 和 ObjectInputStream不能序列化static和transient修饰的成员变量

对象序列化机制：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oMhEKEdA-1572964999180)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1569997011723.png)]

要实现序列化的类
1.要求此类是可序列化的，实现serializable接口
2.要求此类的属性同时也要实现Serializable接口
3.使用一个版本号private static static final long serivalVersionUID
4.使用static 或者 transient修饰的属性，不能实现序列化

Random AccessFile类

支持随机访问的方式，程序可以直接跳转到文件的任意地方来读，写文件

支持之访问文件的部分内容
可以向已经存在的文件后追加内容。

该对象包含一个记录指针，用以标示当前读写处的位置。RandomAccessFile类对象可以自由移动记录指针：

long getFilePointer():获取文件记录指针的当前位置
void seek(long pos): 将文件记录指针定位到pos位置。

构造器

public RandomAccessFile(File file, String mode)

public RandomAccessFile(String name, String mode)

mode: 1.r：只读的方式打开。2. rw：打开以便于读取和写入.3.：rwd：打开以便读取和写入：同步文件内容的更新。4. rws：打开以便于读取和写入：同步文件内容和元数据的更新

多线程

程序，进程，线程； java中多线程的创建和使用，1.继承Thread类与实现Runnable接口2.Thread类的主要方法 3.线程的调度以及设置优先级。；线程的生命周期；线程的同步；线程的通信；

程序：(program)

是为了完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程：(process)

是程序的一次执行过程，或者是正在运行的一个程序。动态过程：有它自身的产生，存在和消亡的过程。

程序是静态的，进程是动态的。

线程：(thread)

进程可进一步化为线程，是一个程序内部的一条执行路径。

如果一个程序可以同一时间执行多个线程，就是支持多线程的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s98Ej1Op-1572964999180)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1570027619253.png)]

1.创建一个集成Thread的子类
- 2.重写Thread的run()方法，方法内实现此子线程要完成的功能
- 3.创建一个子类的对象
- 4.调用线程的start(),启动此线程。调用的run()方法
- 5.一个线程只能执行一次start();
- Thread的常用方法
- 1.start():启动线程并执行相应的run()方法
- 2.run():子线程要执行的代码放入run()方法中
- 3.currentThread():静态的，调取当前的线程
- 4.getName():获取此线程的名字
- 5.setName():设置此线程的名字
- 6.yield():调用此方法的线程释放当前CPU的执行权
- 7.join():在A线程中调用B中线程的join()方法，表示，当执行到此方法，
- A线程停止执行，直到B线程执行完毕，A线程再接着join()之后的代码执行。
- 8.isAlive()：判断当前是否存在
- 9.sleep(long l): 显示的让当前线程睡眠l毫秒
- 10.线程通信：wait() notify() notifyAll()
- 设置优先级
- getPriority(),返回线程优先级设置优先级保证抢到线程的概率变大。
- setPriority(int newPriority), 改变线程的优先级
- MAX_PRIORITY = 10; MIN_PRIORITY = 1; NORM_PRIORITY = 5；
- setPriority(Thread.MAX_PRIORITY);

实现多线程的第一个方法：第一种方法，继承Thread方法；第二种方法，实现Rnunable的接口；

*Runable是一个和多线程有关系的接口
*实现的方式好于继承的方式：
*1.避免了java单继承的局限性
*2.如果多个线程要操控一份资源，要更适合使用实现的方式。
*

1.使用实现的方式创建多线程
2.创建一个实现Runnable的接口类
3.实现接口的抽样方法，子线程执行的代码
4。创建一个Runnable接口实现类的对象
5.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，
将此对象作为一个线程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OG7uwA6R-1572964999180)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1570251542041.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0uHm94lW-1572964999180)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1570251602028.png)]

线程的生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-08s3Pjpo-1572964999181)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1570251679438.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bfIgKMe5-1572964999181)(C:\Users\xc\AppData\Roaming\Typora\typora-user-images\1570252137633.png)]

线程安全问题：由于一个线程在操纵共享数据的过程中，为执行完的情况下，另外的线程参与进来，导致共享数据存在了安全问题。

解决：必须让一个线程操纵共享数据完毕之后，其他的线程才有机会参与共享数据的操作。

java如何实现线程的安全：线程的同步机制。

1.同步代码块：Synchronized

synchronized(同步监视器) {
	//需要被同步的代码块（即为操作共享数据的代码）
}
1.共享数据：多个线程共同操作的同一个数据（变量）
2.同步监视器：由一个类成员变量的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码，俗称：（锁）
要求：所有的线程公用一把锁。

2.同步方法：

将操作共享数据的方法声明为synchronized.即此方法为同步方法，能够保证当其中一个线程执行此方法时，其它线程在外等待，直至线程执行完毕此方法。
同步方法的锁：this
对于静态方法，如果使用同步，默认的锁为：当前类，单例的懒汉式为例，Class class = Singleton.class

3.释放锁的操作：

1.当前线程的同步方法，同步代码块执行结束；
2.当前线程在同步代码块，同步方法中遇到break，return终止了 该代码块，该方法的继续执行。
3.当前线程在同步代码块，同步方法中出现了未处理的Error或者Exception，导致异常结束；
4.当前线程在同步代码块，同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

4.不会释放锁的操作：

线程执行同步代码块或者同步方法时，程序调用Thread.sleep(),Thread.yield()方法暂停当前线程的执行；
线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放锁
尽量避免使用suspend（）和resume（）来控制线程。

6.线程通信，以下三个关键字必须在同步代码块中执行。

wait:一旦线程执行到wait（），就释放当前的锁。
notify / notifyAll：一旦一个线程执行到wait()的一个或者所有的线程；

java中的常用类

字符串相关类：

String类（不可变的字符序列），

StringBuffer类（可变的字符序列），

StringBuilder类（可变的字符序列，效率更高，但线程不安全）

添加：append（）方法，删除：delete（int startIndex, int endIndex) 修改：setCharAt(int n, char ch)

查询：CharAt(int index), 插入：insert(int index, String str) 反转：reverse（）；。

时间相关的类：System类，Date类，SimpleDateFormat类，Calendar类，

数学：Math类，

步方法的锁：this
对于静态方法，如果使用同步，默认的锁为：当前类，单例的懒汉式为例，Class class = Singleton.class


3.释放锁的操作：

1.当前线程的同步方法，同步代码块执行结束；
2.当前线程在同步代码块，同步方法中遇到break，return终止了该代码块，该方法的继续执行。
3.当前线程在同步代码块，同步方法中出现了未处理的Error或者Exception，导致异常结束；
4.当前线程在同步代码块，同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。


4.不会释放锁的操作：

线程执行同步代码块或者同步方法时，程序调用Thread.sleep(),Thread.yield()方法暂停当前线程的执行；
线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放锁
尽量避免使用suspend（）和resume（）来控制线程。


6.线程通信，以下三个关键字必须在同步代码块中执行。

wait:一旦线程执行到wait（），就释放当前的锁。
notify / notifyAll：一旦一个线程执行到wait()的一个或者所有的线程；


#### java中的常用类

字符串相关类：

##### **String类（不可变的字符序列）**，

##### **StringBuffer类（可变的字符序列），**

#####  StringBuilder类（可变的字符序列，效率更高，但线程不安全）

添加：append（）方法，删除：delete（int startIndex, int endIndex) 修改：setCharAt(int n, char ch)

查询：CharAt(int index), 插入：insert(int index, String str)  反转：reverse（）；。

时间相关的类：System类，Date类，SimpleDateFormat类，Calendar类，

数学：Math类，

BigInteger和BigDecimal类，

漫步星云

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java学习笔记

short s = 10;s = s + 5; //会造成编译异常， s 自动类型转化成ints = (short)(s + 5)s += 5这两种情况则，并不会造成编译异常。对于byte, short, int, long 而言，创建数组之后，默认的值为0；对于float， double而言，创建数组之后，默认值是0.0对于char类型而言，默认是空格对于引用类型而言，默认...
复制链接

扫一扫