Java修饰符的访问权限

Java输入易错区

Scanner对象输入时，next()、nextInt()等next开头的方法（nextLine()除外）会扫描缓冲区内容，如果为空，则扫描输入的内容，扫描到第一个分隔符前结束并返回。第一个分隔符后面的所有内容都会存在键盘缓存区。再次一个next()方法扫描缓冲区时，会扫描第一个分隔符后面的内容（不包括分隔符，扫描到下一个分隔符停止）然后返回。next()扫描完缓冲区到回车时，不会结束回车。

nextLine()方法会先扫描缓存区内所有内容（包括间隔符，不包括回车）并返回。扫描完后会结束回车。

因此在前面输入时调用非nextLine()方法，后面要先写一个scanner.nextLine();来扫描掉这个回车，在使用nextLine()来输入。

Java类型强制转换

byte、short、char、int、long、float、double

——————>从低到高可以依次自动转换

变量类型 变量名 = （强转类型=前面变量类型）被转换变量名

适用8中基本类型之间

Integer.parseInt(string);

String 转换为 int

String a=new String(byte类型数组名);

byte 转换为 String

String a=new String(char类型数组名);

char 转换为 String

byte 对象名=Byte.valueOf(字符串)

将字符串String类型转换为byte类型并赋值给“对象名”

Java方法@Override（重写）与@Overload（重载）

@Override（重写=覆盖）——>子类重写父类方法体，但方法名和参数相同

@Overload（重载=重构）——>写一个新的方法，方法名相同，参数不同

Java多态详解

当一个抽象类为Animal 他的子类为Dog

Animal dog=new Dog();

编译时为Animal 运行时为Dog

=前的类名决定了代码提示展示的内容 编译时类型 决定可以调用那些属性和方法

=后的类名（构造方法）决定了对象类型 运行时类型 决定属性和方法是否们能够调用

Java的finally修饰词

修饰的类为最终类，不能被继承。

可以修饰方法，修饰的方法不能被覆盖 。

可以修饰属性，修饰的属性不能在任何地方被修改，这个属性被创建时就要有值。

abstract:（抽象的）

修饰类，该类为抽象类 抽象类不能被实例化

修饰方法要去掉方法作用域，并在方法结尾加“;”

抽象方法只能出现在抽象类中，非抽象类不能有抽象方法

只有抽象类和方法，没有抽象属性

子类除非实现父类的所有抽象方法，否则子类必须是抽象类（接口同样）

匿名类

一个抽象的类实例化时需要实现抽象方法，例如：

Animal animal=new Animal() {

@Override

public void move() {

System.out.println("水里游得");

}

};

看似创建抽象类的对象，实质上是创建了抽象类的子类，覆盖子类方法并实现

由于创建的子类没有名字，因此称为匿名类

animal是创建的对象 Animal是抽象父类 匿名类是创建的子类

匿名对象

People p1=new People();———>People p1=new People();

Dog dog=new Dog(); —————>p1.pet=new Dog();

p1.pet=dog; ————————>没有声明对象名，因此为匿名对象，只能调用这一次

intterface：（接口）

接口:接口不能添加属性、方法

可以添加抽象方法，方法的public abstract可以不用写

接口可以让两个毫无相关的类实现相同的方法

实现接口的类必须实现接口全部抽象方法，否则该类必定是抽象类

接口是用来被实现的，不能创建对象

Serializable 是系统提供的一个接口，没有定义任何方法

(飞机和鸟这两种类的飞行方法，无直接父类，用接口)

Have——a

extend：（继承）

与接口异同

相同 使用一个大的类型表示一系列小的类型都表示一种规范，模版存在

继承只能继承一个父类，接口可以实现多个接口，以“,”隔开。继承可以继承方法和属性 接口只有抽象方法，没有属性 接口只能定义静态常量 public static final

Is——a

static：（静态的）

修饰方法可以不实例化直接调用

修饰属性也可以直接调用

Java中的数组

数据类型 对象名[]={值1，值2，值3，......}

数组使用：对象名[索引值]（索引值从0开始）

数组在范围之外=数组越界

int 数组长度变量=数组对象名.length (定义数组长度)

数据类型 对象名[]=new 数据类型[数组长度] （创建一个指定长度的数据，值都为0）

除了8个基本数据类型，其他初始化数组都为空

调用数组中的每一个元素叫做遍历

数组声明: 数据类型[] 数组名称; 推荐使用，更规范

数组赋值（初始化）:静态初始化:创建数组的时候直接为数组中元素赋值

数据类型[] 对象名=new 数据类型[]{值1，值2，值3，......} 可以省略为:数据类型 对象名[]={值1，值2，值3，......}(不推荐)

动态初始化:需要指定数组的长度（容量），最多存储多少个元素，每个位置存放的元素都是对应数据类型的默认值 数据类型[] 对象名=new 数据类型[数组长度]; 可以通过索引来设置或者读取数组，索引从0开始

Java中的集合

Java 中关于容器提供了两个接口 :Collection,Map 都可以用来存储多个元素

继承Collection接口的常用接口：list、set

Collection、list、set都是接口

List 中的元素可以重复

List 的实现类很多，常用ArrayList

ArrayList长度可变，可以添加不同类型的元素

size(); 可以获取容器长度，元素个数 对象名.size();

add(放入值); 可以放入容器 对象名.add(放入值，可以不同数据类型);

get(想要取出元素的索引值); 取出容器中元素 对象名.get(索引值);

get();方法取出来的为Object类型

remove(索引值/元素值); 删除容器中的元素 对象名.remove(索引值/元素值); 删除时注意！传给remove()方法的元素值应该是整体元素值。例如:一个students集合，想要删除不止要传给remove()方法 students的某一个属性，要传整个student才能删除

removeAll(集合对象名); 删除一组元素，传一个Collection对象，删除的元素为调用该方法的集合中，与传进去的集合相同的元素

clear(); 清空集合

indexOf(元素值); 根据元素值获取该元素在集合中的索引值 对象名.indexOf(元素值); 如果返回索引为-1，则说明集合中无该元素

contains(元素值); 返回值为boolean 类型 判断集合中是否包含该元素

Set 中元素不可重复

Set 的实现类也很多，常用HashSet

HashSet使用方法和ArrayList几乎一样 区别在于添加元素不能重复

Set是无序的，没有索引的概念，通过遍历和添加顺序无关，ArrayList有索引概念

不能指定获取Set中的某一个元素 必须通过遍历判断去获取指定元素 所以没有get();方法

实际开发中并不会使用ArrayList存多种类型 通常作为可变长度数组使用只会存储一种数据类型

Map跟Collection不同在于

Map为两个容器，一个存key，一个存value

同时key和value存在一一对应的关系

key—>Set 不允许有重复元素

HashMap<String, String> map=new HashMap<String, String>();

HashMap<数据类型, 数据类型> 对象名=new HashMap<数据类型, 数据类型>();

Set<String> keysSet=map.keySet(); 获取Map中的key 容器是Set

value—>List 允许有重复元素

Collection<String> value=map.values(); 获取Map中的Value 容器是Collection

map.put(key,value); 存储，包含key：不可重复。value:存储的内容，可重复

map.get(key); 只能根据key获得value值，不能反过来，Map中无索引概念

map.remove(key); 根据key删除容器中的 Key和Value

遍历: 分别遍历key或value或者直接遍历key、value :

Set<Map.Entry<String, String>> entry=map.entrySet();

Set<Map.Entry<数据类型, 数据类型>> 对象名=map.entrySet();

e.getKey(); 获取Key的值 e.getValue; 获取Value值

Map是没有顺序的，遍历的顺序和添加的顺序无关，不一定一致

Hashtable : HashMap和Hashtable的区别在于，table中value不能为空(null)

map中的value可以为空(null)

其他使用方式完全一致

无论任何情况下，禁止在容器遍历情况下修改容器长度(添加元素或删除元素) 否则会导致未知错误

增强for循环

for(数据类型 实例化对象名:数组名){便利数组中的每一个元素}

数据类型一定要和数组或集合类型保持一致 只能用来遍历数组和集合

实例化对象名:在每一次循环中就表示索引对应的元素

Iterator （迭代器接口）

用来遍历接口

Iterator iterator =arrayList.iterator();

while(iterator.hasNext()){}

iterator.hasNext()

返回值boolean 类型，用来判断容器的遍历是否到达末尾

Object object=iterator.next();

集合中类型不确定，因此定义一个Object 类的对象来传元素值

System.out.println(object);

通过next();方法获得容器中的每一个元素

Java中的泛型

泛型名称通常从下面几个字母中选:

T:type 最常用

E:Element

K:Key

V:Value

泛型可以在类、接口、方法中使用，创建泛型时不用声明什么类型，实现含泛型的类、接口、方法时要给泛型制定具体类型

泛型通常用在集合中[（容器）Collection、Map]用来指定容器中元素的类型

例：

ArrayList<存储类型/存储类名> list"实例化对象名"=new ArrayList<存储类型/存储类名>();

后面<>中内容可以省略

声明泛型放在类名、方法名、借口名后

Java中的基本类型和引用类型

基本数据类型和引用类型在内存分配上有很大区别 代码执行要读入到内存中

Java中的内存详解

JVM(虚拟机)中的内存空间可简单分为

栈(Stack):占用空间较小，读取速度较快

栈上内存由计算机自动分配和释放

堆(heap):占用空间较大，读取速度相对较慢

堆上内容由程序员手动分配和释放

常量区:不会变化的数据

静态变量:static修饰的变量与方法

代码区:.class文件内容，代码结构方法

类的元数据区：存放生成类的元素对象

new——>分配空间

Java中采用GC的机制（GC : 垃圾回收机制 释放不再使用的内存空间），有JVM帮我们回收

内存泄漏 : 使用完的内存空间没有释放，导致可用内存空间减少。如果内存泄漏过多会导致程序奔溃

内存分配

基本数据类型都放在栈上，占用空间小

引用类型所占空间比基本数据类型大很多，所以引用类型的值放在堆上，并在栈上保留一个堆的地址引用

基本数据类型值在栈上，相互独立

引用类型值在堆上，栈上只是堆的地址引用，对堆上的值进行修改，所有栈上引用都受影响

变量名/指针：因为变量经常使用，所以内存分配在栈上。

变量为基本数据类型 : 值在栈上

变量为引用数据类型 : 值在堆上

当一个引用类型中有另一个引用类型属性时，该引用类型堆上存储的是 另一个引用类型属性的堆上的地址

例 : 一个Teacher类中含Student属性，当创建一个Teacher对象和一个Student对象 后，把Teacher的Student属性初始化为Student对象的值 则Teacher中Student属性的值存储的是Student对象的地址，Student对象的值存储在Student开辟的堆上

ArrayList 添加元素是存数元素堆上的地址

常量存储机制

Java中认为-128~127之间的数字为常用的，把这些数字对象定义为常量对象，当使用 -128~127之间的数字对象时，引用指向常量区的同一个数字

如果使用new创建新对象，即便在常量范围内也要新建对象

Boolean中的两个值也定义为常量

String不使用new直接初始化，则值存放在常量区（首先去常量区查看是否有改值的常量，有则直接指向该常量，无则创建后指向该值）

对于多次使用的字符串，使用常量（指向常量空间）节省空间

对于使用一次的字符串，使用变量（new一个新空间）使用完即释放内存

Java中的自动拆装箱

对于基本数据类型 Java有自动装箱拆箱的操作

装箱

实现基本类型和引用类型的相互转换装箱，自动把基本类型转换为对应的引用类型

arrayList.add(10);——>arrayList.add((new Integer)10)

拆箱

自动把引用类型转换为对应的基本类型

Integer a=100+200;

两个栈上基本类型相加得到一个堆上引用类型

可以相互混用，系统自动转换

当集合不使用泛型，则默认为Object类型，没有对应的基本类型，无法自动拆箱

Java中基本类型对应的引用类型

基本类型(栈上)——>引用类型(堆上)

byte——>Byte

short——>Short

int——>Integer

long——>Long

float——>Float

double——>Double

char——>Character

boolean——>Boolean

集合中的基本类型实际上是对应右边的引用类型

Java中IO常用语句

二进制文件一般使用字节型io

FileInputStream 对象名=new FileInputStream（"文件路径"）;

文件读入，将文件中的数据读入电脑

FileOutputStream 对象名=new FileOutputStream（"文件路径"）;

文件写出，将电脑中的数据写出到文件

字符文件使用字符io

FileReader 对象名=new FileReader("文件路径");

文件读入，将文件中的数据读入电脑，char类型读入（汉字不会出现乱码）

FileWriter 对象名=new FileWriter("文件路径");

文件写出，将电脑中的数据写出到文件 直接String类型输入

当用Writer输入时;

对象名.newLine();可以换行（只有writer可以有换行）

Object文件io

ObjectOutputStream

ObjectInputStream

writeObject(object对象名);

object写入，每次写入一个对象

readObject();文件object类型读取，返回值为object，每次读取一个对象

对象io写入时必须进行对象序列化:序列化过程就是把对象中的数据转换成二进制的过程，让电脑可识别

Serializable : 可序列化接口

implements Serializable，实现该接口就可以自动实现序列化

IO缓存区读写

以上四种都有Buffered方式

例

BufferedInputStream 对象名=new BufferedInputStream(FileInputStream创建的对象名);

BufferedOutputStream——同上

BufferedReader——同上

BufferedWriter——同上

创建一个缓存空间，运行时间远远小于直接FileInputStream输入文件

io流结束后注意关闭close()

buffered开辟缓存空间时，有可能因为缓存空间未存满导致无法读写。

使用 .fulsh();强制将缓存空间刷新并关闭，在缓存空间未满情况下执行读写操作

IO中常用到的一些方法

字符串.startsWith（String）

当调用这个方法的意思是字符串以什么开头，返回值是boolean

字符串.endsWith

当调用这个方法的意思是字符串以什么结尾，返回值同样是boolean

字符串.split("分割位置标记")

当调用这个方法是，将字符串以“分割位置标记”为基准分割，当标记为“|”时，会将字符串每一个单独拆分出来

字符串.getBytes()

将字符串转换为byte类型

字符串.toCharArray();

将字符串转换为char类型

字符串.toLowerCase();

将字符串转换为小写

字符串.toUpperCase();

将字符串转换为大写

read()方法是一个需要传入一个数组并且返回值为int类型的方法

当FileInputStream.read(byte数组)

当FileReader.read(char数组)

返回值为读入的内容长度，当该值为-1时没有值被读入 该方法是读取文件的操作）

readLine();

直接读取一行的信息，返回值即为该行字符串

String string=new String(value, offset, count)

value为转换为String类型的值，一般为byte或char数组

offset为需要转换数组起始索引值，一般为0

count为需要转换的长度

枚举（enum）

通过在枚举中定义选项，对部分内容做规范。

定义类中属性时，如果属性的值是一个可选的范围，则使用枚举。

可选范围较大时，使用枚举

会增加复杂度，则不适用

枚举不能被继承

每一个枚举都本质上是一个最终类继承自系统的enum，因此不能被继承

例如 ： public final class Week extends enum（伪代码，无法实现）

枚举中可以定义属性和方法，可以正常调用 可以写构造方法，但是必须用private修饰

枚举类型相当于每一个都是枚举的一个对象

默认调用无参构造方法，如果重载则会导致报错，必须将对象调用的无参构造改为有参

枚举可以实现接口

Java中的一些常用类及其方法

.File类

file.createNewFile()

新建一个文件

boolear类型返回值,是否操作成功

file.file.delete()

删除一个文件

boolear类型返回值,是否操作成功

file.renameTo(file2)

把file变成file2

该方法是重命名,把file2放进去重命名并修改路径

boolear类型返回值,是否操作成功

file.list()

返回路径下所有文件及文件夹名字

返回值为String数组

file.listFiles()

返回路径下所有文件

返回值为File数组

file3.getName()

返回文件的名称

返回值为String类型

file.getPath()

返回文件相对路径

返回值为String

file.getAbsolutePath()

返回文件绝对路径

返回值为String

file3.isDirectory()

判断是否为文件夹

返回值为boolear

file3.isFile()

判断是否为文件

返回值为boolear

Date类（时间类）

Date date = new Date();

无参构造

返回现在计算机时间

Date date = new Date(long参数);

long参数构造

返回19700101_080000加上long值的毫秒值

System.currentTimeMillis()

获取从19700101_080000到现在的毫秒数

SimpleDateFormat类 : 时间转换类

SimpleDateFormat format = new SimpleDateFormat()

时间转换器

format.format(date)格式化时间方法

返回值为String

返回默认格式时间

SimpleDateFormat format = new SimpleDateFormat(时间格式)

时间格式：yyyy 年份 MM 月份 dd 日期 hh 小时 mm 分钟 ss秒

format.parse(string)将字符串换为Data类型

返回值为Data

字符串必须和Data格式相同

Calendar类 : 日历类

Calendar calendar=Calendar.getInstance()

创建日历对象

calendar.get(int参数)

int静态常量，标识方法返回的属性

也可以调用其他静态常量返回其他属性

该方法返回值的月份是从0开始的,星期从周日开始为1，依次到周六为7

System.out.println(calendar.get(Calendar.YEAR)); 打印年

System.out.println(calendar.get(Calendar.MONTH)+1); 打印月

System.out.println(calendar.get(Calendar.DAY_OF_MONTH)); 打印几号

Date也可以

System.out.println(calendar.get(Calendar.DAY_OF_WEEK)); 打印周几（周日为第一天）

calendar.set(field, value);

设置日历，field 选择设置内容（静态常量选择）value设置值

calendar.add(field, amount);

设置日历 field 选择设置内容 amount 在当前日期基础上向前或者后推的值

calendar.getActualMaximum(Calendar.DAY_OF_MONTH)

返回一个月的最大天数

返回值为int

Integer类

Integer.parseInt(string)

将string转化为integer类型

Integer.parseInt(string, radix);

String类型

radix为进制

将该进制转换为10进制

Integer.max(4, 5)

求最大值

Integer.min(4, 6)

求最小值

Integer.sum(1, 4)

求和

Integer.toBinaryString(int);

将int转换为2进制

Integer.toHexString(int);

将int转换为16进制

Math类

Math.random();

生成0<=i<1的随机数

Math.floor(double);

将double向下取整

返回值为double

Math.ceil(double);

将double向上取整

返回值为double

StringBuffer类：拼接字符串类

article.append(content)

将content拼接到article中

（关注小编可获得最新java信息相关内容）