java学习

JVM

jvm：java虚拟机，是运行java程序的虚拟的计算机，是Java程序的运行环境

2

Java常量

  1. 字符串常量 例如 “dsdsa”,”dasdsad”
  2. 整数常量 例如 1 5 8
  3. 浮点数常量 2.02 8.36
  4. 字符常量 ‘d’ ‘\a’
  5. 布尔常量 true false
  6. 空常量 null

java 打印输出

Java 在两行System.out.println(“a”)与System.out.println(“b”)两行之间会有换行，例如

1
2
System.out.println("dad");
System.out.println("da");

结果会输出

dad

da

注意：空常量不能打印输出

Java基本数据类型

整数型 byte short int long

浮点类型 float double

字符型 char

布尔型 bolean

rf

java数据类型转换

和c++一致，Java有显示和隐式转换，但是从大范围到小范围的隐式数据转化，Java不在支持，必须为显示转换，当然，Java中不存在static_cast<>()这种转换

注意

  1. 强制类型转换最好不要使用，会有精度损失

相加操作例如 byte+byte 两个byte都会隐式转换为int，必须加上强制类型转换。

但是对于short/int/byte而言，如果右值没有超过范围，则编译器会进行隐式的转换，例如

short a=20;

不会报错，如果右侧大于范围，例如，char a=555;则编译器报错

但是加上操作符之后会有类型的提升，例如，short+short应该用int来接。但是右侧表达式为常量，则不会报错。short a =1+5;不会报错

注意 java死循环后面不能再加上语句

IDEA的项目结构

idea项目结构

javamulu

所有开发的源代码需要在src下，EL代表外部依赖项。最细致的管理代码的单位叫做包。其中包是一个多层级文件夹的嵌套例如我创建cn.a.b的包，系统会创建cn的文件夹，在cn文件夹下创建a文件夹，在a文件夹下创建b文件夹。

快捷键

Java函数的调用与函数的重载与c++一致

java内存可以分为以下几类

java内存分类

Java使用类操作

  1. 导包

import 包名.类名

如果两个文件属于同一个包，则不需要import操作

  1. 使用类

Student s=new Student();

  1. 使用

注意：只有java.lang下的包不需要导包，其他的包都需要导入

IDEA 生成简单代码

选择最上方code，然后选择generate.如果需要选择多个功能的生成，可以按住shift键

Scanner

键盘输入

Scanner在java.util下，使用键盘输入写为 Scanner sc=new Scanner(System.in);获取输入的int 为

int a=sc.nextInt();字符串为 String s=sc.next();

Random

1
2
3
Random R=new Random();
int a=R.nextInt();//随机生成一个int值
int b=R。nextInt(9);//生成[0,9)的随机int数

ArrayList

如同vector

1
2
ArrayList<int>a=new ArrayList<>();
a.add(100);

方法列举

1
2
3
add
get(int index);
int remove(int index);//删除idnex下的元素，返回该元素

list.fori遍历ArrayList

如果ArrayList里面装的是基本类型，则需要在左边模型参数中写入下面代码

java基本类型包装类.jpg

String类

对于String类，例如”dsadasds”字符串被当作一个实例，不像c++当成字面值，而是一个String类的对象，也有内存。这也就意味着java不像C++是通过char*来构建String，而是把String当作一个对象。这也就意味着不能通过[]操作来访问String 元素。但是都可以使用char[]创建String

  1. 字符串的内容不可改变

  2. 每一个” “字符串不认为是一个字符串常量，而是一个有地址的

String方法

,equal(String)如果两个字符串内容相同，不管地址相不相同，都返回true.

推荐常量字符串调用方法

.equalIsIgonreCase()；equals方法的增强版，忽略大小写

.indexOf(string);//返回参数字符串在字符串的位置

.concat(String s);//将调用字符串与s拼接，并返回

.charAt(char);//charAt(char);//返回字符在字符串中的位置

.substring(int begin);//从begin开始到末尾的字符子串

.substring(int begin,int end);//[begin,end)dgin,end)的字符子串

string其他方法.jpg

String[] spilt(string a);//按照规则a切分字符串

1
2
3
String a="aaa,bbb,ccc";
String[] b={"aaa","bbb","ccc"};
//规则a是个正则表达式

并且和c++一致，所有对象共享用同一份static。和c++完全yi’zhi

静态代码块

当第一次用到本类时就会调用静态代码块

1
2
3
4
5
6
7
public class a
{
	static
	{
	
	}
}

Arrays

Arrays.sort(数组)//对数组排序。如果是结构化数组，需要指出Comporable或Comporator接口

Math

Math.abs();

Math.ceil();向上取整

Math.flood();向下取整

Math.PI;

子类与基类

public class 子类 extends 父类

{

}

和c++规则一致，并且还没有虚函数

忘记保存了 从继承到内部类的内容全没了

干

算了 从匿名内部类开始把

匿名内部类

如果接口的实现类或者父类的子类只需要实现一次，则可以使用匿名内部类

例如可以在mainh函数内部写上

接口名称 对象名=new 接口名称(){里面覆盖重写接口的方法};

匿名内部类的注意事项

  1. 创建匿名内部类的对象是，只能创建一次

System类

  1. System.currentTimeMillis();//返回程序现在的毫秒值

  2. array copy函数

arraycopy函数.png

StringBuilder类

  1. StringBuilder原理

StringBulider原理.png

StringBuilder 有参数为String的构造方法

对象.append(任意的基本类型和字符串);返回this,并将任意的类型转化为StringBuilder里的bytes数组,该类比String的效率高，因为采用了缓冲区。

  1. toString方法，将StringBuilder对象转化为String对象

包装类

将基本数据类型包装成类，可以调用成员方法

包装类.png

装箱与拆箱

将int装箱 Integer a=new Integer(int string);

拆箱 a.intVal()

自动装箱 Interger a=11;

自动拆箱 a+=2；

将字符串变为int double

Integer类里面有static int parse(String a);

Collection 集合

Collect类.png

Iterator 迭代器

迭代器的使用

  1. 使用集合中的方法iterator()获取迭代器的实现类对象

  2. 使用迭代器的hasNext();方法判断有没有下一个元素

  3. 使用next();获取下一个元素

创建迭代器

Collection a=new ArrayLisr<>();

Iteratora=a.iterator();

泛型

与c++一致，定义泛型的方法如下 public class 类名 <模板参数>{}

泛型定义方法.png

泛型接口与泛型类一致，接口向右写，并且模板参数可以默认

含有泛型的方法

修饰符 <模板参数> 返回值 名称(参数){}

Colleciton类

sort

要想在自己写的类实现Collection.sort()方法，必须将该类实现一个接口Compareable<类名>并重写方法compaeTo方法。升序用this-对象。

也可以这样重写函数

1
2
3
4
5
6
Collections.sort(aa, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return 0;
    }
});

map集合

两个模板参数，也是键值对

hashmap

hashmap通过put方法插入，get方法通过键获得值

remove(键)。删除键所对应的值，并放回

keyset 将map中的所有键返回为一个集合。然后y可以通过key找到value

Entry对相当于C++的pair对象，map对象可以调用EntrySet对象返回

1
2
hashMap与HashTable的区别
map允许键值为空，table不允许键值为空

of方法一次性添加LIST SET MAP接口，一旦一次性添加了元素，便不能再put元素

1
List<String>s=List.of("a","b","c");

Set使用of方法如果有重复的参数，会抛出异常

调试跟踪

f8逐行执行程序
f7进入方法体;
shift+f8调处方法体
f9跳到下一个断点，没有就推出
CTRL+f2调处程序
Console 切换到控制台

异常

Java中异常是个类，产生异常会抛出一个异常的类

throwable下面有两个子类 error和excepions类，该包再lang包下
使用try catch代码块可以捕获异常，并且后续代码可以实现
try
{}
catch(Exception e)
{}

异常处理的过程

异常处理过程.png

异常的处理

throw关键字

使用俄式 throw new xxxException(“长生异常原因”);

注意事项

  1. throw关键字必须写在方法的内部
  2. throw后面new的对象必须是Exception或者Exception类的子类对象
  3. throw关键字抛出异常后我们必须处理这个异常
    throw关键字抛出的RunTimeException或者其子类的对象可以不用处理
 编译异常要么使用throws要么使用try  catch 代码段

Object.requireNonNull(T obj,String 打印信息);如果对象obj为空，会抛出一个异常，叫做空指针异常

如果有多个异常，并且两个异常有继承关系，那么，在抛出异常的时候只需要抛出父类的异常例如

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) throws IOException {
    fun("C://a.txt");

}
public static void fun(String add)throws IOException
{
    if(add.equals("C://a.txt"))
        throw new FileNotFoundException("没找到文件");
    if(!add.endsWith(".txt"))
        throw new IOException("文件后缀名错误");
}

没有抛出FileNotFind异常是因为他是IOException异常的子类,通过throw的方式，异常后的代码不在执行

try catch

try catch后续代码都会执行。可以修改以上的代码块，使用try catch方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args)  {
    try
    {
        fun("dasdsa.ds");
    }
    catch (IOException e)
    {
        System.out.println("后续");
    }
    System.out.println("呆呆的撒");
}
public static void fun(String add) throws IOException {
    if(!add.endsWith(".txt"))
        throw new IOException();
    System.out.println("后缀名一致");
}

finally代码块无论有没有异常，都会执行的代码块

异常的处理

  1. 分步别try边catch
  2. 可以这样一次try多次catch
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args)  {
    try
    {
        fun("dasdsa.ds");
    }
    catch(IOException)
    {
        
    }
    catch(FileNotFoundException)
    {
        
    }
}

3 多异常一次捕获，一次处理

1
2
3
4
5
6
7
8
9
public static void main(String[] args)  {
    try {

    }
    catch(Exception e)
    {
        System.out.println(e);
    }
}

自定义异常

自己写的异常类必须继承Exception 一个无参的光谱早方法一个带有父类信息的构造方法

Java的thread类

妈的多线程的一章全没了 >o<

File类

java IO包类
file 文件
directiry 文件夹/路径
path 路径

构造函数
File(String a);//a为绝对路径或者相对路径
File(String parent, String zi);//父路径与子路径

.getAbsolutePath();//获取绝对路径
getPath();//获取相对路径
.getName();//获得文件、文件夹名称。
.length();//文件的大小.

.exist();//判断路径是否存在

.isFile();//判断是否是文件
.isDirectory()l//判断是否是文件夹

.creatNewFile();//创建一个新文件
.delete();//删除文件或文件夹
.madir();//创建路径

FileFileter

FileFilter接口用于过滤File对象
只有一个抽象方法 boolean accept(File ovj);
用法
实现该接口的accept方法，调用路径的的listFiles(参数为实现类对象);这样就过滤了。
方法返回true 则放入数组中。

FileFilter原理.png

I\O

文件字节输出流

  1. 创建FileOutputSvrean对象

  2. 调用对象的write方法

  3. 调用close释放资源

    .write(byte[]);会写入byte类型的所对应的字符。如果第一个数字是正数，会对应ASCII码输入对应字符，如果第一个是负数，会将两个正数对应GBK汉字输入。

在文件后面追加写数据

​ 创建FileOutputSvrean时，使用两个参数的构造方法，FileOutputStream(String a,bollean flag);如果flag为true会在原文加后面追加文件，否则会覆盖重写文件

字节输入流

​ InputStream抽象类，定义了所有的输出流的抽象方法

FileInputStream

​ 构造方法，参数和上面一样，参数为文件的路径

字符输入流 Read

​ 抽象类，read()一次读取一个字符，close释放资源方法。一个一个字符的读取

FileRead
  1. 创建FileRead对象
  2. 使用read方法读取文件 返回值为-1，则read失败
  3. close
字符输出流

  1. 创建FileWriter对象，构造方法写入目的地址

  2. 使用write方法写道内存的缓冲区中

  3. 使用flush把内存缓冲区的数据，刷新到文件中

  4. close

    flush会刷新流对象的内容到文件，流对象继续使用。close之后流对象会释放

和字节输入输出流一样 使用第二个参数的构造函数会续写文件。\r\n换行

IO异常

​ JDK7之后再try后面加一个括号，写上流对象，在try执行完毕，会释放流对象。不再写finally释放流对象

​ JDK9之后可以不用在括号内创建对象，只需要在括号内写上外边定义的对象，类似代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) throws IOException {
    FileOutputStream fileOutputStream = new FileOutputStream("a.txt");
    FileInputStream fileInputStream = new FileInputStream("b.txt");
    try(fileInputStream ; fileOutputStream){
        int ln=0;
        while((ln=fileInputStream.read())!=-1)
        {
            fileOutputStream.write(ln);
        }
    }
    catch (IOException e)
    {
        System.out.println(e);
    }
}

字节缓冲输出流

BufferedOutputStream(OutputStream a);会给a创建一个缓冲区。

使用步骤

  1. 创建输出 FileOutputStream对象
  2. 通过1创建的对象创建缓冲流对象
  3. 使用2的write方法写道缓冲区中
  4. 使用flush写道文件中
  5. close

字节缓存输入流与输出流类似，只是没有flush.close的时候只需要关闭缓冲流即可，无需关闭原始流。

序列化与反序列化

序列化：ObjectOutputStream把对象写入到文件中 writeObject,

反序列化：ObjectInputStream(返回object类) readObject

进行序列化和反序列化的对象必须实现Serializable接口

如果类的内容变化，则会抛出异常，序列化与反序列化不一致，解决方式是在类中声明一个变量 private static final serialVersionUID

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码