java核心包是什么 java的核心包是什么

java基础

1、Java核心的基础

java的优点

• 运行速度快
• 面向对象编程
• 跨平台性（一次创建导出运行）

java中的名词表示

• jDK：jre+开发工具
• jre：java开发环境+类库
• jvm：java开发环境

字符集

unicode：都是两个字符，但是支持全部的编码集

utf-8：变长的（中：3个字节1个字符），支持所有的字符集

GBK：两个字节一个中文字符

2、基本数据类型的包装类

java基本数据类型的包装类用法与基本数据类型一致，但是这些包装类提供了一些相关的方法。

注：在开发的时候多采用平时类型，少采用包装类

int类型的强制转换

String a="10";
        String b="10";
        String c=Integer.parseInt(a)+Integer.parseInt(b)
        System.out.println(c);

字符串的优先级>数字的优先级>boolean

3、运算符

• +：既可以是两个数字相加，也可以是字符串的拼接
• /：在进行出发运算的时候，其结果只返回整数部分
• ++：b=a++；表示先给b赋值，之后在进行++操作，当b=++a时，a先执行++操作之后在将a的值赋给b
• –：与++的操作一样
• +=：a+=1类似与a=a+1

三元运算符

int a=10;
int b=a>10?20:30;
System.out.println(b);

4、控制语句

if {
    ...
}else{
    ...
}

for循环

for(int i=x;i<xx;i++){
    
}

while(){
    
}

while(判断条件){
    //先判断在执行
    //输出语句
    //迭代
}

do{
    //先执行在判断，至少执行一次
    //输出语句
}while(判断条件);

switch(keysS){
        case value:
        System.out.println("你好世界")
        break;
        .....
        default;
        System.out.println("你好世界")
        break;

}

continue:跳出当前循环，执行下一次的循环，break是结束当前循环

增强for循环

5、数组

数组的创建赋值以及输出

//        未知数组值的情况

        int[] arr=new int[3];
        arr[0]=1;
        arr[2]=2;
        arr[2]=3;
//        数组的输出方式
        System.out.println(Arrays.toString(arr));

//        已知数组的数值情况
        int[] arr1=new int[]{1,2,3};
        int[] arr2={1,2,3}
        System.out.println("===========================");
        System.out.println(Arrays.toString(arr1));

数组的遍历

//       增强for循环，主要是来进行遍历容器，在使用的时候建议不要修改其中的值
        for (int i : arr) {
            System.out.println("数组的遍历第一种方法");
            System.out.println(i);
        }

        for (int i=0; i<arr.length; i++){
            System.out.println("第二种遍历方式");
            System.out.println(arr[i]);
        }

6、面向对象

成员变量是由初始值的，但是局部变量是没有初始值的。

成员变量一般设置在方法外部，但是局部变量是设置在内部

Java的修饰符

• 范围修饰符

• public
• protectes
• friendly
• private

• 功能修饰符

• final
• static

方法的重载

• 方法名相同
• 方法参数的数量、数据类型、顺序至少有一个不相同

注：静态方法也可以重载，兼容不同类型的重载，当Object，与String方法重载的时候采用近者优先的原则

注：子类也可以重载父类的方法，构造方法也常用重载

构造方法的定义

在创建对象之后同时调用的方法

• 创建方式

• 构造方法不能有返回值
• 方法名必须与类名相同

• 作用

• 一般是用来初始化成员变量

• 注意点

• 类在创建实例化时会自动调用构造方法。如果创建了自定义的构造方法，则会执行你自定义的构造方法，如果没有自行创建，则系统会自行定义一个无参的空的构造方法进行执行。
• 在其他普通的方法之中不能构造方法。
• 构造方法之后两种构造方式一个java虚拟机的调用，一个是构造方法之间是可以互相调用的
• 当在一个构造方法之中调用其他的构造方法的时候，必须是调用构造方法的语句位于第一行

• 优点

• 更加的符合面向对象的要求，更加的符合实际的情况

this的使用

this.类似于一个指针，this一般是志向自己。是当前对象的一个引用，一般是隐藏在当前的休想中

• 作用

• 区分局部变量与成员变量，以及父类变量或者是方法

• 使用规则

• 必须是构造方法，但必须是第一条语句
• 静态方法中不能使用this

6.1、封装

封装继承多态

封装：将所有的成员放到类中

良好封装的条件：建议使用get与set方法来创建

静态成员

• static的特性

• 静态成员是属于类的，确切的说不是属于类的实例的
• 静态成员在类中只有一份
• static在类被实例化的时候static中的方法便会被执行

• 什么时候使用静态代码块

• 类中的所有的对象共有一个统一的属性
• 凡是不使用实例成员变量的方法就可以设置为静态方法

6.2、继承

继承

• 在继承之后，子类拥有父类的public 与protected的成员与方法
• 为什么使用继承

• 提高了代码的复用，

• java不直接支持支持单继承的模式，只能一次继承一个父类
• super

• 当子类继承父类之后，super所指代的元素指的是父类中的元素

方法重载的作用

重载与重写的区别

重写equal方法

作用

注：在java中通过一个new、new出来的对象会在内存中创建一个新的地址

”==“是用来比较两个数的地址是否相同

• equals的作用是来比较两个变量的值是否相同

注：在子类中无法重写父类的构造方法

继承中的构造方法

• 当继承关系建立时，子类构造函数中会默认加入一条语句super();因此：当创建子类实例时，先调用的是父类的构造方法，然后菜调用子类的构造方法
• 子类对象创建时，默认必须调用谷类中的无参构造方法
• 如果想调用父类带参的构造，子类需要显示的在子类构造中使用super（参数）这句代码来明确要调用那个父类的构造：且这条语句必须是第一句
• 当继承关系建立时，所有子类的构造方法中，都在方法开始处隐式添加一条语句，super()，即调用父类的无参构造

常量（final）

final int a =10;

常量的特点：赋值之后便无法在进行赋值

使用final修饰方法

final public  void aa(){
    
}

当final修饰方法之后，方法无法进行重写

final修饰类

final class a{
    
}

使用final去修饰类，则这个类不能被继承

6.3、多态

6.4、抽象方法（abstract）

定义：没有方法体的方法称为抽象方法，作用一般是为了让其子类进行重写

abstract public void test();//创建抽象方法

抽象类

注：抽象类是不能被实例化的

特点

• 如果使用抽象类，则一定是父类
• 抽象类一定不能被实例化
• 因为需要被其他类继承，所有抽象类是有构造方法的
• 抽象类可以不定义抽象方法的

一个类中如果者是抽象方法，则这个类一定是抽象类，但是一个抽象类中不一定有抽象方法

抽象类继承

abstract class Animal{
    public int val=10;
    abstract public class void eat();
}

abstract class Bird extends Animal{
    abstract public void fly();
}

注：抽象类可以无限的继承

6.5、接口

特点

• 接口之中只能有全局变量，public static final（即：常量）
• 接口中的所有的成员方法都是public abstract的
• 接口中的所有的成员都是public

7、集合

java的数组是静态数组，必须要指定数组的长度

集合框架

容器，放置其他引用数据类型的对象。

• 集合是指java中用于保存对象的容器
• 特点

• 集合是用来存储对象的容器（不包括基本的数据类型）
• 集合中不可以存储基本数据类型
• 集合的长度是可变的
• 集合中存储的是对象的引用

import java.util.ArrayList;

public class demo01 {
//    集合的测试
    public static void main(String[] args) {
        //integer是int的对象
        ArrayList<Integer> list=new ArrayList<>();
        int a=1;
        //在进行添加的时候，会进行一定的操作，因此a将不是一个基本的类型
        list.add(a);
        System.out.println(list.toString());
    }
}

注：java的集合框架分为单列存储：Collection与双列存储：Map

集合： ArrayList、

• list

• 可重复，有序的。

import java.util.ArrayList;

public class demo01 {
//    集合的测试
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        int a=1;
        list.add(a);
        list.add(2);
        list.add(3);
        list.add(3);
        System.out.println(list.toString());
    }
}

set

import java.awt.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

public class demo02 {
    public static void main(String[] args) {
//        获取set
        Set<String> set=new HashSet<>();
        set.add("aaaa");
        set.add("bbbb");
        set.add("ccc");
        System.out.println(set);
    }
}

set是无序的

TreeSet(自己有自己的而排序方式)

import java.util.TreeSet;

public class demo03 {
    public static void main(String[] args) {
        TreeSet<String> set =new TreeSet<>();
        set.add("aaaaaaaaaa");
        set.add("1111111111");
        set.add("222222222222222");
        set.add("3333333333");
        set.add("bbbbbbbbbbbbbbb");
        System.out.println(set.toString());
    }
}

7.2、map

import java.util.HashMap;
import java.util.Map;

public class demo04 {
    public static void main(String[] args) {
        Map<String,Object> map=new HashMap<>() ;
        map.put("name","小蜜瓜");
        map.put("name1","小蜜瓜1");
        map.put("name2","小蜜瓜2");
        System.out.println(map.toString());
    }
}

注：map中的key是不能重复的，没有自己的遍历的方式

map的遍历的方法

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class demo04 {
    public static void main(String[] args) {
        Map<String,Object> map=new HashMap<>() ;
        map.put("name","小蜜瓜");
        map.put("name1","小蜜瓜1");
        map.put("name2","小蜜瓜2");
        System.out.println(map.toString());
        Iterator<String> iterator = map.keySet().iterator();
        Iterator<Map.Entry<String, Object>> iterator1 = map.entrySet().iterator();
        while (iterator1.hasNext()){
            Map.Entry<String, Object> next = iterator1.next();
            System.out.println("Entry=>遍历"+next.toString());
        }
        System.out.println("iterator为=>"+iterator.toString());
        while (iterator.hasNext()){
//            System.out.println(iterator);
//            System.out.println("map的迭代=>"+iterator);
            String key = iterator.next();
            System.out.println("获取key=>"+key);
        }
    }
}

建议使用entry进行遍历，entry的效率较高

8、IO流

inputStream、outputstream、Reader、writer都是抽象类

inputStream、outputstream是以字节的方式进行传输

Reader、writer都是抽象类是以字符（字节加编码表）的方式进行传输

文本文档，编码表是以字符的方式进行传输

图片，文件都是以字节的方式进行传输

8.1、字符流

writer（文件的创建即文件内容的填写）

import java.io.FileWriter;
import java.io.IOException;

public class demo05 {
    public static void main(String[] args) throws IOException {
        FileWriter fileWriter = new FileWriter("E:\\Hello2.txt");
        fileWriter.write("aaaa");
        fileWriter.close();
    }
}

Reader（文件的读取）

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class demo06 {
    public static void main(String[] args) {
        FileReader fileReader=null;
        try {
            fileReader=new FileReader("E:\\Hello2.txt");
//            读取文件的内容
            int read = fileReader.read();
            System.out.println(read);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

注：建议使用BUfferFilter进读取

BufferWriter

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class demo07 {
    public static void main(String[] args) {
        FileWriter fileWriter= null;
        try {
            fileWriter = new FileWriter("E:\\Hello2.txt");
            BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
            bufferedWriter.write("adadadwa");
//            进行刷新
            bufferedWriter.flush();
            bufferedWriter.newLine();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

8.2、字节流

leWriter= null;
try {
fileWriter = new FileWriter(“E:\Hello2.txt”);
BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
bufferedWriter.write(“adadadwa”);
// 进行刷新
bufferedWriter.flush();
bufferedWriter.newLine();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}

}

}

### 8.2、字节流

[外链图片转存中...(img-JJPQ1Uo9-1639040895268)]