java基础

零：idea快捷键

ctrl+alt+t；if，switch，try catch等

alt+insert 所有方法：set，get，等

ctrl+o 类重写方法

ctrl+l 接口重写方法

ctrl+j 显示快捷键：init

查看数据类型：getCLass.toString

一.java运行机制

Text.java (编译javac)>Text.class （运行）>各个平台jvm

jdk : jre（jvm + java核心库） +java开发工具(javac，java ，javap,javadoc 等)

二.环境变量理解

a. 配置java环境变量才能全局调用java

b. Windows系统中有两种环境变量：用户变量和系统变量

1、环境变量没有区分大小写，例如path跟PATH是一样的

2、系统变量对所有用户有效

3、用户变量只对当前用户有效

三.变量

一个源文件中最多只能有一个 public 类

java集合接口

java数据类型

整型默认是int，声明long需要加L/l

浮点型默认是double，声明float需要加F/f

String 转 int

String str = "hello";

//转成 int

int n1 = Integer.parseInt(str);

System.out.println(n1)

四.运算符

+，-，*，/，%，i++，++i
< , > , != , >= , <= , == , instanceof (检查是否是类对象)
&&，||，|, &，|，^

不管前面的条件是否正确，后面都执行。 &&,||：前面条件正确时，才执行后面，不正确时，就不执行,开发中，我们使用的基本是使用短路&&,||

4.+=, -=, %=, *=, /=

a+=b => a=a+b

5.原码，反码，补码

注意（对于负数）>> 是对负数的补码进行操作：-15>>1

-15 ：10001111 反码：11110000 补码：11110001 => 11111000(补码)

11110111（反码） 10001000（原码） => -8

五.程序控制结构

for

while

do while

break

continue

return

lable1

六.数组，排序，查找

1.数组： double [] a={0.1,0.2,0.3,0.4,0.5,0.6}

创建：1.double[] ab=new double[5];

2.double ab[]=new double[5];

3.double ab[];

ab=new double[5]

2.排序：（冒泡）

3.查找：（二分，顺序）

4.二维数组

     int[][] b1 = new int[3][4];
    
    int b2[][];
    b2=new int[3][4];
 
    int b3[][]={
            {1,2,3,4},
            {5,5,9,3},
            {0,0,5,8}
    };

七.面向对象编程（初级）

1.对象

Cat cat1=new Cat()

一般变量存放与栈，对象存放与堆

2.方法

无参

public void speak(){
}

有参

public void speak(String name){
}

3.传值，传址

传值（基本数据类型）（传的是数，不改变实参的值）

传址（引用类型）（像传数组，传对象都是就传地址，都会改变实参）

4.递归

5.方法的重载

方法名必须相同

形参列表必须不同（类型或者个数或者顺序）

6.可变参数 int...

当同一个类中有多个同名同功能，不同个数的形参时，可以用可变参数int...

可作为数组使用,本质是数组

可以有一个或者多个参数

一个形参列表只能有一个可变参数，但是可以有多个不变参数（如（对：String a，int... b），（错：int... a，double... b））

7.作用域：

全局变量（属性）：无需赋值，直接使用。有默认值（作用域为整个类)，

局部变量（属性）：需要赋值后才能使用。

class Cat{

int a1;

cay(){

int a2=0; }

}

属性的生命周期随着对象创建而创建，随着对象销毁而销毁

8.构造方法，构造器

前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。

[修饰符] 方法名(形参列表){ 方法体; }

 1) 构造器的修饰符可以默认， 也可以是 public protected private 
2) 构造器没有返回值，**但是不能写void**
3) **方法名（构造方法） 和类名字必须一样** 
4) 参数列表 和 成员方法一样的规则 
5) 构造器的调用, 由系统完成，本质完成对象初始化
6) 可以创造不同的构造器，即构造器的重载

9.this

表示当前对象的属性是谁

(即只能在构造器中访问另外一个构造器, 必须放在第一条语句) this 不能在类定义的外部使用，只能在类定义的方法中使用。

八.面向对象编程中级

1.private，public

注意：在同一个类中，可以访问private，protected，public

在同一个包下，不同类中，不能访问private，只能通过类里的public方法访问私有属性，方法。

2.封装（set，get）

封装就是把抽象出的数据[属性] 和对数据的操作[方法] 封装在一起数据被保护在内部,程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。

过程：属性私有化，public set（进行输入数据要求和需求），public get（设置输出数据需求）

3.继承（extends）

1.使用

为什么继承：a代码复用b代码，a,b两个方法功能有很多都一样

class 子类 extends 父类

super：当创建子类对象时，默认调用父类的无参构造器，完成父类的初始化，若父类没有提供无参的构造器，则要再子类的构造器用super去指定父类那个构造器完成父类的初始化。

如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数）

super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)

super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)

**//(1) 首先看子类是否有该属性 **

**//(2) 如果子类有这个属性，并且可以访问，则返回信息 **

**//(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息..) **

//(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到 Object

2.super和this

super

super.属性名（父类private属性不可调用）

super.方法名（父类private方法不可调用）

super（参数列表）；（只放在第一句，调用构造方法）

this

3.方法重写/覆盖(override)

子类有个方法和父类的某个方法的名称，返回类型，参数一样，则子类的方法覆盖了父类的方法，或者重写了该方法。

注意：子类的方法名和参数列表必须和父类保持一致。

子类不能缩小父类的权限。

子类的返回值类型必须是父类的类型，或者父类返回类型的子类。

4.多态

1.方法的重载，重写体现多态。

重载：

System.out.println(a.sum(10, 20)); System.out.println(a.sum(10, 20, 30))；

重写：

a.say();

b.say();

2.编译类型，运行类型

Animal animal = new Dog();

Animal animal = new Cat()；

其中Animal，animal是编译类型，Dog，Cat是运行类型

3.多态的向上转型和向下转型

向上a：Object a=new String()

向下b：Object a=new String()

String b=(String) a

4.instanceOf

比较操作符，用于判断对象的运行类型是否为 X,或X的子类型

然后向上转型调用方法

a instanceof String

（(String)a).Fangfa();

5.动态绑定机制

当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

当调用对象属性的时候，没有动态绑定机制，哪里声明，哪里使用

6.多态应用

多态数组 ：数组的定义类型为父类类型，里面保存的实际元素类型为子类类型

多态参数

7.equals，hashcode，toString，finalize

equals 重写

hashcode

1.提高具有哈希结构的容器的效率

2.两个引用，如果指向的是同一个对象，哈希值肯定是一样的

3.两个引用，如果指向的是不同对象，哈希值是不一样的

4.哈希值主要根据地址号来的，不能完全将哈希值等价于地址

5.hashcode在后面集合中会重写

finalize: 垃圾回收机制

九.面向对象编程高级

1.类变量（静态变量）

对于独立于对象的变量

public static int a;

1.对于a，全局都可以访问，采用类.a 形式。

2.static变量，在类加载的时候就形成了。

3.static变量，是同一个类，所有对象共享这个变量。

4.当我们需要让所有对象共享一个变量时，就需要用到类变量

5.类变量的生命周期随类开始，随类消亡。

2.类方法（静态方法）

1.定义：

public static void Tool(double a){

}

2.使用：

类.方法或者类定义对象，对象调用方法

3.经常使用场景

当不想定义实例对象，有需要使用方法的时候，例如：工具类使用

4.注意

类方法中没有this和super，普通方法可以使用

静态方法只能访问静态变量，普通方法可以访问静态变量和非静态变量

3.main方法

public static void main(String[] args){

}

注意：为什么是public 因为main方法是被java虚拟机调用，属于全局调用。

为什么是static，因为java虚拟机调用时不需要创建一个实例对象。

String[] args数组保存了java运行时所要传递的所有参数。

4.代码块

使用：

static {}

{}

意义：

静态代码块或者非静态代码块，属于类的一部分，相当于补充构造方法。

注意：

类初始化时，代码块调用的顺序优先于构造器。

代码块和属性初始化地位相同，都高于构造器。

静态代码块又是高于普通代码块。

{}代码块随着对象被创建而执行，可以执行多次. 而且可以使用this.age=age

static {}代码块，只能被执行一次。并且不能使用this.age=age

类什么时间被加载：

1.new一个对象时

2.创建子类，父类也会被加载

3.调用类的静态方法，静态对象时

5.顺序

1.父类静态代码块和父类静态属性初始化

2.子类静态代码块和子类静态属性初始化

3.父类普通代码块和父类普通属性初始化

4.父类的构造方法

5.子类普通代码块和子类普通属性初始化

6.子类的构造方法

6.单例模式

1.定义

对于某个类，只能存在一个对象实例，并且只提供一个取得对象实例的方法。

2.分类

饿汉式和懒汉式

对于懒汉式，当调用时，对象才会被创建

3.创建

将构造器私有化

私有化构建一个static对象

public static 一个方法，返回一个对象

7.final使用

本质：常量

当修饰类时，类不能被继承

当修饰父类方法时，方法不可被重写

当修饰属性（类里面的变量）时，属性不可被修改

当修饰局部变量（类里的方法里的变量）时，局部变量不能被修改

8.抽象类（abstract）

1.为何出现

因为我们在写一个父类时，需要写一个具体的实现方法，但事实上我们还不知道要实现什么功能，所有，使用抽象方法代替。

抽象类，是使用abstract去修饰一个类，跟多用于设计，开始时，构建好整个项目所需要的抽象父类，而后使用各种子类完成以后需要的各种功能。

2.注意

抽象类里面不一定有抽象方法，但是如果有抽象方法就必须在使用时重写，

抽象类不能被实例化

abstract只能修饰类和方法

abstract方法不能用private，static，final修饰,因为都不能被重写。

3.使用：

abstract class Animal{

abstract public void eat();

}

9.接口

1.定义：

interface AA{

属性

抽象方法

}

class BB implements AA{

自己属性

自己方法

实现抽象方法

}

2.注意

一个接口的属性只能时public static final int a=10;

接口不能继承类，但可以继承其他接口

类可以继承多个接口

使用接口名.属性名调用属性

3.继承和接口区别

首先，类的继承是解决代码的复用性。接口相当于功能的扩展。

接口比继承更灵活，继承是是它，而接口是像它。

其次，接口相当于对继承机制的补充。子类可以直接继承和使用父类的功能，但没有扩展功能，而接口可以实现扩展功能。

4.接口多态传递现象

如果IG继承了IE接口； interface IG extend IE{}

teacher类又实现了IG接口：IG ig = new teacher();

那么我们可以得到teacher类也实现了IE接口 IE ie=new teacher()

10.类的五大属性

属性，方法，构造器，代码块，内部类

11.内部类

1.定义：定义在一个类的内部，可以访问私有属性。

2.分类：在方法或者代码块位置：局部内部类（有类名），匿名内部类（没有类名）

在成员成员位置：成员内部类（没有static），静态内部类（有static）

局部内部类：在外部类的方法或者代码块中写类，在外部类的方法中创建对象并使用。内部类可以调用使用外部类的私有变量，不能添加修饰符，只有final可以使用

 public void IntName(){
        class Innerclass{
            private int age=20;
            private String sex;
            public Innerclass(String sex){
                this.sex=sex;
            }
            public void JS(){
                System.out.println("外部公有姓名："+name+"\t"+"外部私有年龄："+age+"\t\t"+"内部私有性别："+sex);
            }
        }
 
//        使用
        Innerclass innerclass = new Innerclass("男");
        innerclass.JS();

匿名内部类：

匿名类实现接口，类构造器，抽象类

 public void OFang(){
    JK jk = new JK() {
        public void protede() {
            System.out.println("匿名类实现接口");
        }
    };
    jk.protede();
}
 
//接口
interface JK{
    public void protede();
}

成员内部类：在外部类的成员位置，在外部使用。可以访问外部类的私有变量，可以添加修饰符(public，private...）。

访问方法1:

 class OutLei{
    private int age=10;
    public String name;
    public class InnerLen{
        String sex;
        public void By(){
            age=20;
            System.out.println("haha"+age);
        }
 
    }
}

OutLei.InnerLen innerLen = new OutLei().new InnerLen();

访问方法2（需要返回一个对象）:

OutLei.InnerLen obt = new OutLei().getObt();

静态内部类：在外部类的成员位置，并有static修饰，可以访问外部类的static变量，不能访问非静态变量，可以添加修饰符（public，private...）。

 class Dt{
    String id;
    int age;
    static String School;
    static public class DTClass{
        public void dft(){
            School="szxy";
            System.out.println("hello,I am sattic Class"+School);
        }
    }
 
    public DTClass GetObj(){
        return new DTClass();
    }
 
}

访问方法和访问成员内部类相同。

十.枚举和注解

1.0枚举介绍

为什么使用：针对于只读的对象，使用枚举更快速，方便

使用注意：默认大写，public final static 修饰

构造方法私有化

可以有get方法，不能有set方法，防止被修改

再枚举类里构建对象

1.1枚举注意

自定义枚举类 class Season 和 使用关键字自定义枚举类的区别 enum Season

使用关键字 enum 时，会隐式继承 Enum

增强for循环的使用

values，tostring，valueOf，compareTo，ordinal，name 等方法使用

1.2枚举类的继承和实现接口

使用 enum 关键字后，就不能再继承其它类了，因为 enum 会隐式继承 Enum，而 Java 是单继承机制。

枚举类和普通类一样，可以实现接口，如下形式。 enum 类名 implements 接口 1，接口 2{}

2.0注解介绍

Annotation 注解可以被编译运行,前面要加@。

1.@Override 重写父类的方法

2.@Deprecated 表示某个程序（类，方法）过时

3.@Suppress Warnings 抑制编译器警告

jdk的元注解

1.Retention //指定注解的作用范围，三种SOURCE,CLASS,RUNTIME

2.Target // 指定注解可以在哪些地方使用

3.Documented //指定该注解是否会在 javadoc 体现

4.Inherited //子类会继承父类注解

十一.异常

1.基本概念

程序发生不正常情况为异常（开发中，逻辑和语法错误不为异常）

2.异常分类

Error（错误）：java虚拟机无法解决的问题，如jvm内部错误，资源耗尽，栈溢出

Exception：因为编程错误或者偶然外部因素，如空指针访问，读取不存在文件

分为两大类：运行时异常和编译时异常

3.异常结构图

4.注意

对于编译时的异常必须要处理

对于运行时的异常可以不做处理

5.异常举例

运行时异常：

NullPointerException 空指针异常
ArithmeticException 数学运算异常
ArrayIndexOutOfBoundsException 数组下标越界异常
ClassCastException 类型转换异常
NumberFormatException 数字格式不正确异常[]

编译时异常

SQLException 操作数据库时，查询表可能发生异常

IOException 操作文件时，发生的异常

FileNotFoundException 当操作一个不存在的文件时，发生异常

ClassNotFoundException 加载类,而该类不存在时，异常

EOFException 操作文件，到文件未尾，发生异常

lllegalArguementException 参数异常

6.异常处理

1.try catch

2.try catch finally

3.try可以捕捉不同的异常，可以有多个catch

4.try finally 相当于没有捕捉异常，必须执行某个业务逻辑

注意：对于try出现异常时，直接到catch，不会再去执行异常语句下面的语句

7.抛出异常（throws）

注意：

对于运行时的异常可以在调用时可以不做处理，最终交予JVM处理，JVM简单粗暴，直接断开或者崩溃。

对于编译时的异常，在调用时必须处理使用try catch或者将其抛出给上一级，如果选择抛出，最终抛到JVM，JVM简单粗暴，直接断开或者崩溃。

可参考：extion4

8.自定义抛出异常(throw)

自定义异常类继承Exception（编译异常）或者 RuntimeException（运行异常）(一般使用)

注意：throw new AgeException("hello")，可以抛出这个异常，

在调用该方法中使用try catch捕捉这个异常 Exception e，输出e.getMessage

十二.常用类

1.包装类

1.1介绍：8种基本类型

数值型

byte => Byte

short => Short

int => Integer

long => Long

float => Float

double => Double

字符串

char => Character

布尔型

boolean => Boolean

例子：

对于装箱（jdk5之前）：int => Integer

int n1=10;

Integer integer0 = new Integer(n1);

Integer integer1 = Integer.valueOf(n1)

对于拆箱（对于jdk5之前）：Integer => int

int i=integer0.intValue();

对于自动装箱（jdk5之后）：int => Integer

int n1=10;

Integer integer0 =n1;

对于自动拆箱（对于jdk5之后）：Integer => int

int i=integer0;

注意：自动装箱，拆箱本质还是手动装箱和拆箱的valueOf和intValue的调用。

1.2包装类和String类互换

Integer => String

Integer+""; //法一

Integer.toString; //法二

String.valueOf(integer); //法三

String =>Integer

Integer.parseInt(str); //法一

new Integer(str); //法二

1.3Integer的缓存空间

IntegerCache缓存区间为[-128,127]

针对Integer integer2=127

 			1.	如果所创建的2个对象在-128到127区间内，无需创建对象，可以直接从缓存区间拿出，并且地址也是相同的。
			2.	如果所创建的2个对象不在-128到127之间，需要创建两个对象，存入缓存区间，并且地址不同。

针对Integer integer0 = new Integer(1);

是直接创造对象，所以地址一定不一样

System.identityHashCode（）可以查看内存地址

2.String类

2.1创建String

注意：String a="hello" 和 String a=new String("hello")的区别

   对于第一种创建String,先在常量池检查是否有hello，
  *       如果有则直接指向常量池的地址，
  *       如果没有则在常量池中创建hello，再指向常量池
  *       最终返回的是常量池的地址

   对于第二种创建String,先在堆中创建一个新的对象，在去常量池中查看是否有hello,
  *       如果有则直接指向常量池，
  *       如果没有，创建则在常量池中创建hello，在指向常量池
  *       最终返回的是堆的地址

2.2String对象内存分析

1.注意事项：String 是final，是不可变的，一旦分配，内存不可变。

如果对其重新赋值，会在底层常量池重新创建对象，然后重新指向该对象内存

2.注意事项：对于String s="hello"+"wjc" 在jvm中会进行优化，相当于String s="hellowjc"，在底层只创建了一个对象
3.注意事项：对于String a="wang"，String b="jiChun"，String c=a+b 注意这里总共创建了3个对象。

并且对于c，在底层调用StringBuffer，在append(a).append(b)

对于常量相加，看的是池

对于变量相加，看的是堆

2.3String类常用方法

equals 区分大小写，判断字符是否相同

equalsIsIgnoreCase 忽略大小写，判断字符是否相同

length 获取字符个数，字符串长度

indexOf 获取字符在字符串第一次出现的索引，从0开始，找不到返回-1

lastIndexOf 获取字符最后一次出现的索引位置，找不到返回-1

substting 截取指定范围子串

trim 去前后空格

charAt 获取某索引处的字符

toUpperCase 小写转大写

toLowerCase 大写转小写

concat 将字符串连接在后面

replace 替换字符串中的字符

split 分割字符串，注意转义

compareTo 比较两个字符串大小

toCharArray 转换字符数组

format 格式字符串，%s,%d,%c,%.2f String.format("姓名%s 年龄%d",name,age)；

2.4StringBuffer

为什么引入StringBuffer和StringBuilder，因为String类是保存字符串常量的，每次更新字符串都需要重新开辟空间，效率地下，从而提出他们来增强String的功能

介绍：

是一个可变的字符串，可对字符串进行增加，删除，并不改变内存地址

是一个容器

String与StringBuffer的相互转换

String a="wjc";

StringBuffer buffer=new StringBuffer(”hello“);

String => StringBuffer

法一：

StringBuffer bu=new StringBuffer(a);

法二：

StringBuffer buffer1=new StringBuffer();

StringBuffer bu=buffer1.append(a);

StringBuffer => String

法一：

String s=buffer.toString();

法二：

String s=new String(buffer);

2.5StringBuilder

为什么在存在stringBuffer的情况下，又引入StringBuilder，因为StringBuilder用在单线程字符串缓冲区要比StringBuffer更快，缺点是不能多线程同步（不能保证线程安全）

注意：StringBuilder主要操作：append，insert，可重载，接收任意类型数据

2.6比较

String：不可变字符串，复用率高，运行效率低，常用来定义不可变配置

StringBuffer：可变字符串，运行效率较高，常用来处理多线程数据修改处理

StringBuilder：可变字符串，运行效率最高，常用来处理单线程数据修改处理

3.Math类

abs（-3）绝对值 -3的绝对值

pow（2，4）幂 2的4次幂

ceil（3.2）向上取整

floor（3.2）向下取整

round（4.4）相当于 floor（4.4+0.5）四舍五入

sqrt（9）开方

random（）随机生成数[0，1）

(int)(a+random()*(b-a+1)) 随机生成[a,b]

min（1,100），max(1,100) 最小值最大值

4.Arrays数组类补充

0.注意int[]={1,5,9,3} 与 Integer[]={1,5,9,3}的区别

1.Arrays.toString(arr); 打印数组

2.Arrays.copyOf(arr,arr.length) 复制数组

3.Arrays.fill(arr,23) 填充数组元素，可以将所有元素转化为23

4.Arrays.equals(arr1,arr2) 判断两个数组是否相同

5.System类

1.System.exit(0) 正常退出 System.exit(1) 非正常退出

2.System.arrayscopy() 复制数组元素，底层调用Arrays.CopyOf()

3.System.gc() 垃圾回收机制

4.currentTimeMillens 返回距离1970-1-1-0-0-0的毫秒数

5.BigIngeter（保存较大整型），BigDecimal（保存较大浮点型），调用简单方法add（加），subtract（减），multiply（乘），divide（除）。

6.date类

Date

1.date类 new date() 获得当前系统时间

2.指定时间格式 String=>date

使用SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 hh:mm:ss E"); String format = sdf.format(d1); // format:将日期转换成指定格式的字符串 System.out.println("当前日期=" + format);

3.String=>date

String s = "1996 年 01 月 01 日 10:20:30 星期一"; Date parse = sdf.parse(s); System.out.println("parse=" + sdf.format(parse）

Calendar

1.Calendar类抽象类

创建对象使用 Calendar cal = new Calendar.getInstance()

使用去获取年：cal.get(Calendar.Year)

等等

Instant

1.Instant 时间戳

Instant i = new Instant().now

2.Instant = > Date

Date from = Date.from(i)

3.Date => Instant

Instant u = from.toInstant()

十三.集合框架

注意：

Collection接口包括：list，set是单列接口；

Map接口是多列接口

1.list

（单列集合，有序，可以存放相同元素）

1.基本操作

add（），remove（），contains（），size（），isEmpty（）

addAll（），removeAll（），containsAll（）

2.iterator 迭代器的使用遍历集合
通过while去遍历迭代器
注意:迭代器经过while循环后最后指向集合的最后一个，如果想再次遍历集合，需要重置迭代器

3.增强for循环遍历集合

for（元素类型元素名：集合名或数组名）{

访问元素

}

2.set

（单列集合，无序，不可以存放相同元素）

3.map

（多列集合）

十四.泛型

1.问题： ArrayList list = new Arraylist()当需要在集合中添加对象时，会有对象数据类型不安全和需要遍历时，需要向下转型

2.解决：使用泛型ArrayList list = new Arraylist()，此时不可以添加除Dog类对象，遍历时直接遍历Gog对象。

3.注意：泛型也可以指类参数的数据类型：E，String，Integer，可以具体指出s的数据类型，也可以用E来表示：如：Preson类或者Preson的参数：String s 或者 E s；定义的泛型：Preson pre1=new Preson 或者 Preson pre2 =new Preson

4.自定义泛型类：class Tiger<T,D,R...>

5.自定义泛型接口 interface Tiger<T,D,R>，实现接口时，直接指定泛型接口的类型class A implements Tiger<String,Integer,Double>

6.静态方法和静态属性都不能使用泛型

7.通配符使用 <?> 支持任意字符，<? extend A> 有上限，<？super A>有下限

十五.多线程

十六.IO流

1.创建（3种方法）：

new File（String pathname）

new File（File parent,String child）

new File（String parent,String child）

并调用createNewFile()执行创建新文件

2.常用方法：

文件名：getName

路径：getAbsolutePath

父目录：getParent

大小：length

是否为文件：isFile

是否为目录：isDirectory

是否存在：exists

3.目录操作：

创建一级目录：mkdir

创建多级目录：mkdirs

删除空目录，或者文件：delete

4.I/O流

5.读取字节并显示：FileInputStream；read（），read（byte[] b）

6.写入字节文件并保存：FileOutputStream;write

7.读取字符并显示：FileReader

8.写入字符并显示：FileWriter

8.节点流（重一个特定的数据源读取文件）：FileInputStream，FileOutputStream，FileReader，FileWriter；处理流（包装流）(连接在已经存在的流上)：BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter

10.处理流好处：性能的提高:主要以增加缓冲的方式来提高输入输出的效率。
操作的便捷:处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据,使用更加灵活方便

11.序列化和反序列化

序列化就是在保存数据时，保存数据的值和数据类型

反序列化就是在恢复数据时，恢复数据的值和数据类型

必须实现两个接口之一：Serializable；Externalizable

12.对象流：提供了对基本类型或对象类型的序列化和反序列化的方法

序列化：ObjectOutputStream；反序列化：ObjectInputStream

13.序列化和反序列化应用

序列化

 public class ObjectOutStream_ {
public static void main(String[] args) throws Exception {
//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
String filePath = "e:\\data.dat";
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
//序列化数据到 e:\data.dat
oos.writeInt(100);// int -> Integer (实现了 Serializable)
oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
oos.writeChar('a');// char -> Character (实现了 Serializable)
oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
oos.writeUTF("王纪春");//String
//保存一个 dog 对象
oos.writeObject(new Dog("旺财", 10, "中国", "白色"));
oos.close();
System.out.println("数据保存完毕(序列化形式)");
}
}

 // 1.创建流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\data.dat"));
// 2.读取， 注意顺序
System.out.println(ois.readInt());
System.out.println(ois.readBoolean());
System.out.println(ois.readChar());
System.out.println(ois.readDouble());
System.out.println(ois.readUTF());
System.out.println(ois.readObject());
System.out.println(ois.readObject());
System.out.println(ois.readObject());
// 3.关闭
ois.close();
System.out.println("以反序列化的方式读取(恢复)ok~");

13.转换流：

InputStreamReader：可以将InputStream（字节流）转换为Reader（字符流）

outputStreamWriter：可以将outputStream（字节流）转换为writer（字符流）

转化原因：有效解决中文乱码原因；效率更高（对应纯文本文件）；并且可以在使用时，指定编码格式（utf-8,gbk,gb2312）

14.Properties类（读取ip，user，pwd数据）

 public static void main(String[] args) throws IOException {
//使用 Properties 类来读取 mysql.properties 文件
//1. 创建 Properties 对象
Properties properties = new Properties();
//2. 加载指定配置文件
properties.load(new FileReader("src\\mysql.properties"));
//3. 把 k-v 显示控制台
properties.list(System.out);
//4. 根据 key 获取对应的值
String user = properties.getProperty("user");
String pwd = properties.getProperty("pwd");
System.out.println("用户名=" + user);
System.out.println("密码是=" + pwd);
}

15.修改和保存Properties类

 public static void main(String[] args) throws IOException {
//使用 Properties 类来创建 配置文件, 修改配置文件内容
Properties properties = new Properties();
//创建
properties.setProperty("charset", "utf8");
properties.setProperty("user", "汤姆");//注意保存时，是中文的 unicode 码值
properties.setProperty("pwd", "888888");
//将 k-v 存储文件中即可
properties.store(new FileOutputStream("src\\mysql2.properties"), null);
System.out.println("保存配置文件成功~");
}

十七.网络编程

1.本质：两个Socket的交互

2.netstat -an 可以查看当前主机端口监听和网络连接状况

十八.反射

posted @ 2023-12-19 19:23 Wang_JC 阅读(12) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· html,css，javaSript

· Mybatis

· Java知识点总结

· java_简单学习笔记

· java学习笔记

阅读排行：
· 周边上新：园子的第一款马克杯温暖上架
· 分享 3 个 .NET 开源的文件压缩处理库，助力快速实现文件压缩解压功能！
· Ollama——大语言模型本地部署的极速利器
· DeepSeek如何颠覆传统软件测试？测试工程师会被淘汰吗？
· 使用C#创建一个MCP客户端

公告

昵称： Wang_JC
园龄： 1年9个月
粉丝： 1
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

	int[][] b1 = new int[3][4];

	int b2[][];
	b2=new int[3][4];

	int b3[][]={
	{1,2,3,4},
	{5,5,9,3},
	{0,0,5,8}
	};

	1) 构造器的修饰符可以默认，也可以是 public protected private
	2) 构造器没有返回值，但是不能写void
	3) 方法名（构造方法）和类名字必须一样
	4) 参数列表和成员方法一样的规则
	5) 构造器的调用, 由系统完成，本质完成对象初始化
	6) 可以创造不同的构造器，即构造器的重载

	public void IntName(){
	class Innerclass{
	private int age=20;
	private String sex;
	public Innerclass(String sex){
	this.sex=sex;
	}
	public void JS(){
	System.out.println("外部公有姓名："+name+"\t"+"外部私有年龄："+age+"\t\t"+"内部私有性别："+sex);
	}
	}

	// 使用
	Innerclass innerclass = new Innerclass("男");
	innerclass.JS();

	public void OFang(){
	JK jk = new JK() {
	public void protede() {
	System.out.println("匿名类实现接口");
	}
	};
	jk.protede();
	}

	//接口
	interface JK{
	public void protede();
	}

	class OutLei{
	private int age=10;
	public String name;
	public class InnerLen{
	String sex;
	public void By(){
	age=20;
	System.out.println("haha"+age);
	}

	}
	}

	class Dt{
	String id;
	int age;
	static String School;
	static public class DTClass{
	public void dft(){
	School="szxy";
	System.out.println("hello,I am sattic Class"+School);
	}
	}

	public DTClass GetObj(){
	return new DTClass();
	}

	}

	1. 如果所创建的2个对象在-128到127区间内，无需创建对象，可以直接从缓存区间拿出，并且地址也是相同的。
	2. 如果所创建的2个对象不在-128到127之间，需要创建两个对象，存入缓存区间，并且地址不同。

	对于第一种创建String,先在常量池检查是否有hello，
	* 如果有则直接指向常量池的地址，
	* 如果没有则在常量池中创建hello，再指向常量池
	* 最终返回的是常量池的地址

	对于第二种创建String,先在堆中创建一个新的对象，在去常量池中查看是否有hello,
	* 如果有则直接指向常量池，
	* 如果没有，创建则在常量池中创建hello，在指向常量池
	* 最终返回的是堆的地址

	public class ObjectOutStream_ {
	public static void main(String[] args) throws Exception {
	//序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
	String filePath = "e:\\data.dat";
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
	//序列化数据到 e:\data.dat
	oos.writeInt(100);// int -> Integer (实现了 Serializable)
	oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
	oos.writeChar('a');// char -> Character (实现了 Serializable)
	oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
	oos.writeUTF("王纪春");//String
	//保存一个 dog 对象
	oos.writeObject(new Dog("旺财", 10, "中国", "白色"));
	oos.close();
	System.out.println("数据保存完毕(序列化形式)");
	}
	}

	// 1.创建流对象
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\data.dat"));
	// 2.读取，注意顺序
	System.out.println(ois.readInt());
	System.out.println(ois.readBoolean());
	System.out.println(ois.readChar());
	System.out.println(ois.readDouble());
	System.out.println(ois.readUTF());
	System.out.println(ois.readObject());
	System.out.println(ois.readObject());
	System.out.println(ois.readObject());
	// 3.关闭
	ois.close();
	System.out.println("以反序列化的方式读取(恢复)ok~");

	public static void main(String[] args) throws IOException {
	//使用 Properties 类来读取 mysql.properties 文件
	//1. 创建 Properties 对象
	Properties properties = new Properties();
	//2. 加载指定配置文件
	properties.load(new FileReader("src\\mysql.properties"));
	//3. 把 k-v 显示控制台
	properties.list(System.out);
	//4. 根据 key 获取对应的值
	String user = properties.getProperty("user");
	String pwd = properties.getProperty("pwd");
	System.out.println("用户名=" + user);
	System.out.println("密码是=" + pwd);
	}

	public static void main(String[] args) throws IOException {
	//使用 Properties 类来创建配置文件, 修改配置文件内容
	Properties properties = new Properties();
	//创建
	properties.setProperty("charset", "utf8");
	properties.setProperty("user", "汤姆");//注意保存时，是中文的 unicode 码值
	properties.setProperty("pwd", "888888");
	//将 k-v 存储文件中即可
	properties.store(new FileOutputStream("src\\mysql2.properties"), null);
	System.out.println("保存配置文件成功~");
	}

wjc1234

java基础

零：idea快捷键

一.java运行机制

二.环境变量理解

三.变量

四.运算符

五.程序控制结构

六.数组，排序，查找

七.面向对象编程（初级）

1.对象

2.方法

3.传值，传址

4.递归

5.方法的重载

6.可变参数 int...

7.作用域：

8.构造方法，构造器

9.this

八.面向对象编程中级

1.private，public

2.封装（set，get）

3.继承（extends）

1.使用

2.super和this

3.方法重写/覆盖(override)

4.多态

1.方法的重载，重写体现多态。

2.编译类型，运行类型

3.多态的向上转型和向下转型

4.instanceOf

5.动态绑定机制

6.多态应用

7.equals，hashcode，toString，finalize

九.面向对象编程高级

1.类变量（静态变量）

2.类方法（静态方法）

3.main方法

4.代码块

5.顺序

6.单例模式

1.定义

2.分类

3.创建

7.final使用

8.抽象类（abstract）

1.为何出现

2.注意

3.使用：

9.接口

1.定义：

2.注意

3.继承和接口区别

4.接口多态传递现象

10.类的五大属性

11.内部类

十.枚举和注解

1.0枚举介绍

1.1枚举注意

1.2枚举类的继承和实现接口

2.0注解介绍

十一.异常

1.基本概念

2.异常分类

3.异常结构图

4.注意

5.异常举例

6.异常处理

7.抛出异常（throws）

8.自定义抛出异常(throw)

十二.常用类

1.包装类

1.1介绍：8种基本类型

1.2包装类和String类互换

1.3Integer的缓存空间

2.String类

2.1创建String

2.2String对象内存分析

2.3String类常用方法

2.4StringBuffer