本文介绍了Java基础的核心概念，如优点、数据类型包装、运算符、控制语句、数组、面向对象特性、JDK/JRE/JVM，以及字符集。深入探讨了数组、集合（ArrayList、Set、TreeSet、Map）、IO流（字符流、字节流）等内容，适合初学者快速上手。
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)]
扫一扫
4082
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
