一、准备工作
java的历史版本
jdk、jre、jvm
jdk：java development kit【java开发工具包】
jre：java runtime environmen【java运行环境】
jvm：java virtual machine【Java虚拟机】
IDE
integrated development environment：集成开发环境
是整合代码的编写、运行、分析、调试等一系列功能的开发软件
src目录 是source的缩写；程序的后缀是.java
out目录 java程序的输出目录，存放.class的字节码文件，生成字节码文件的过程叫做编译
编译运行的过程
IDEA的基本配置
IDEA的快捷键
ctrl b 或者 ctrl 左击：查看源代码
ctrl d 复制（默认是一行）（否者复制选中内容）
ctrl y 删除
ctrl n 通过类名 定位文件
ctrl f 在当前类中查找 esc可以关闭查找
ctrl / 注释
ctrl alt l 格式化代码
ctrl alt ⬅ 上一次编辑的地方
ctrl alt ➡ 下一次编辑的地方
alt shift 上下箭头 移动行
main方法 psvm
输出 sout
alt 回车 导包
alt insert 构造、getter、setter
alt 回车 重写的快捷键
iter 增强for的快捷键
java编码规范
二、基本程序结构
三种注释
/**
* 文档注释
*/
public class HelloWorld {
/**
* 文档注释
*/
public static void main(String[] args) {
/*
多行注释
*/
System.out.println("2222222");
System.out.println("2222222");
//单行注释
System.out.println("2222222");
}
}
常量
字面值常量
字符串常量、整数常量、小数常量、字符常量、布尔常量、空常量
自定义常量
数据类型
类型转换：默认和强制转换
命名方式
运算符
ASCII表
复制运算符
三元运算符
Scanner的用法
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println(i);
}
switch语句
do while 循环语句
break 和 continue
三、方法
方法、方法重载
四、数组
数组的定义
格式三是格式二的简化
数组的初始化：动态、静态
java的内存分配：方法区、堆、栈
参数传递
基本类型作为参数传递，传递的是 值【按值传递】
引用类型作为参数传递，传递的是 地址值【按引用传递】
五、类和对象
定义类
一个类包括：成员变量和成员方法
创建类的内存图解
对象作为参数的内存图解
成员变量和局部变量的区别
- 内存中的位置：成员变量：堆内存；局部变量：栈内存
- 生命周期：成员变量：和对象的创建消失同步；局部变量：随着方法的调用而存在，随着方法调用完毕而消失
- 就近原则，除非用this关键字
封装（类和对象都有这种思想）
封装的好处：
- 安全性
- 复用性
- 将复杂简单化
private和public
private一般用来形容成员变量
public一般用来形容成员方法
this关键字
表示当前对象的引用
构造方法（可以重载）
- 未提供构造方法，系统默认给你一个无参构造方法
- 已提供了，系统就不再提供
- 构造方法可以重载
六、继承
继承的要点
子类只能继承父类非私有成员（成员变量、成员方法）
继承的优点
- 功能复用
- 便于扩展新功能
- 结构清晰，简化
- 易于维护
继承的缺点
- 打破了封装性
- 高耦合性
程序设计的追求
高内聚、低耦合
就近原则，super关键字
先找局部变量
没有的话，再找本类的成员变量
没有的话，再去父类的成员位置找
继承中成员变量使用图解
在子类方法中调用父类方法 super
public class Fu {
public void fuMethod(){
System.out.println("父类方法");
}
}
public class Zi extends Fu {
public void ziMethod(){
super.fuMethod();
System.out.println("子类方法");
}
}
public class Test {
public static void main(String[] args) {
Zi zi = new Zi();
zi.ziMethod();
}
}
结果：
父类方法
子类方法
子父类构造方法的继承问题
【如果一个类没有构造方法，默认给一个无参构造方法】
子类构造方法第一行默认给一个super()
注意：
如果父类没有无参构造方法，子类构造方法如果不特殊处理，默认第一行super()，会报错。解决措施：子类构造方法第一行，我们写super（参数）访问父类代参构造；或者给父类增加无参构造。
方法重写（Override）
public class Fu {
public void method(){
System.out.println("父类方法");
}
}
public class Zi extends Fu {
@Override
public void method() {
System.out.println("子类中的重写方法");
}
}
public class Test {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}
结果：
子类中的重写方法
复写、覆盖
方法名，参数列表，返回值都需要相同
父类私有方法无法重写。
子类方法的访问权限不能小于父类方法。【必须合乎父类的要求】【子类不能比父类抛出更大的异常】
- 补充：四大权限修饰符：private，不写，protected，public
使用场景
- 扩展
- 父类过时
访问权限符
方法重写和方法重载的关系
继承的特点：
类只能单继承，但可以多重继承
子类不可以继承父类的构造方法,只可以调用父类的构造方法
接口可以多继承：接口A extends 接口B，接口C，…
七、多态
多态的实现步骤
- 要有继承（或实现）关系
- 要有方法重写
- 父类引用指向子类对象
编译看左，运行看右（对于非静态成员方法来说）
编译看左，运行看左（对于成员变量，静态成员方法来说）
public class Animal {
String name = "Animal";
}
public class Dog extends Animal {
String name = "Dog";
}
public class Test {
public static void main(String[] args) {
Dog a = new Dog();
Animal b = new Animal();
Animal c = new Dog();
System.out.println(a.name);//Dog
System.out.println(b.name);//Animal
System.out.println(c.name);//Animal
}
}
instanceof关键字，父子类类型转换
public class Animal {
void eat() {
System.out.println("吃");
}
}
public class Dog extends Animal {
@Override
void eat() {
System.out.println("啃骨头");
}
void watch() {
System.out.println("看家");
}
}
public class Test {
public static void main(String[] args) {
Animal an = new Dog();
if (an instanceof Dog) {
((Dog) an).watch();
}
}
}
抽象方法
有抽象方法的类一定是抽象类。
final关键字
修饰：方法、类、变量
不能与abstrat共用
注意：
final修饰变量的时候：如果变量是基本类型，值不能改变；如果变量是引用类型，地址值不能改变，但是属性值可以发生变化。
八、接口
public interface Smoking {
public abstract void smoking();
}
public class Teacher implements Smoking {
@Override
public void smoking() {
System.out.println("吸烟有害");
}
}
类与类：
- 继承关系，单继承，可多层继承
类与接口：
- 实现关系，可以单实现，也可以多实现
接口与接口：
- 继承关系，可以单继承，也可以多继承
接口中的变量和方法
变量：
【public】【static】【final】变量名 = 数据值；
方法：
抽象方法：【public】【abstract】返回值类型 方法名（参数列表）；
默认方法：【public】default 返回值类型 方法名（参数列表）{方法体}
静态方法：
私有方法：普通私有方法、静态私有方法
接口中没有构造方法。
九、常用API
toString
输出语句直接打印对象，默认调用了该对象的toString()方法。
public class Person {
}
public class Test {
public static void main(String[] args) {
Person p = new Person();
System.out.println(p);//March.Day12.Person@2d98a335
System.out.println(p.toString());//March.Day12.Person@2d98a335
}
}
Scanner类
public class Demo01 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("输入一行");
String str = s.nextLine();
System.out.println("str = " + str);
System.out.println("输入一个整数");
int num = s.nextInt();
System.out.println("num = " + num);
}
}
运行结果：
输入一行
4654fdf dfsf 5456
str = 4654fdf dfsf 5456
输入一个整数
15
num = 15
String类
Date类、Calendar类
public static void main(String[] args) {
//创建，采用当前系统默认时间
Date date = new Date();
System.out.println(date);//Fri Mar 13 15:07:33 CST 2020
//获取毫秒值
long time = date.getTime();
System.out.println(time);//1584083348709
//创建了一个指定时间
Date date2 = new Date(1584083348709L);
System.out.println(date2);
}
public static void main(String[] args) {
//Calendar是抽象类，用getInstance获取对象
Calendar c = Calendar.getInstance();
System.out.println(c);
int year = c.get(Calendar.YEAR);
System.out.println("year:" + year);
System.out.println("-----------------");
c.set(Calendar.YEAR, 8888);
int year2 = c.get(Calendar.YEAR);
System.out.println("year:" + year2);
//重置年月日
c.set(2018, 10, 15);
System.out.println("YEAR:" + c.get(Calendar.YEAR) + " MONTH:" + c.get(Calendar.MONTH) + " DAY:" + c.get(Calendar.DATE));
}
包装类
public static void main(String[] args) {
int i = Integer.parseInt("15624");
System.out.println(i);
double d = Double.parseDouble("256.213");
System.out.println(d);
}
jdk5之后可以自动拆箱，自动装箱
十、集合
迭代方式：
集合和数组的区别
增强for循环、迭代器
iterable接口下都可以用迭代器
除了以上，包括数组都可以用 增强for循环
列表迭代器
list<>接口中有下面的方法，返回一个列表迭代器的实例。
ListIterator<E> listIterator()
返回此列表元素的列表迭代器（按适当顺序）。
public static void main(String[] args) {
List list = new ArrayList();
list.add("sfd");
list.add("b");
list.add("seee");
list.add("lll");
System.out.println(list);
ListIterator lt = list.listIterator();
while (lt.hasNext()) {
String str = (String) lt.next();
if (str == "b") {
lt.add("Java");
}
}
System.out.println(list);
}
[sfd, b, seee, lll]
[sfd, b, Java, seee, lll]
Collections工具类
HashSet<>原理
底层是 哈希表 = 数组 + 链表/红黑树
前提：存储的元素必须重写hashCode方法和equals方法 set.add(元素) 首先调用元素的hashCode方法，计算哈希值，如果set中没有，就直接添加；如果有的话，就调用元素的equals方法和哈希值相同的元素相比较，如果返回false就认定元素不相同，就会把元素存储到集合中，如果返回true就丢弃
所以：存储自定义类型，必须重写equals方法和hashcode方法。
十一、IO流
IO流的分类
File类
file对象的三种构造方法
public static void main(String[] args) {
//构造方法1
File file1 = new File("E:\\abc\\1.txt");
//构造方法2
File file2 = new File("E:\\abc\\", "1.txt");
//构造方法3
File file3 = new File("E:\\abc");
File file4 = new File(file4, "1.txt");
}
创建文件：
File file6 = new File("E:\\abc\\2.txt");
file6.createNewFile();
创建文件夹：
File file7 = new File("e:\\abc\\mason");
file7.mkdir();
FileReader
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("abc/1.txt");
int c;
while ((c = fileReader.read()) != -1) {
System.out.println(c);
}
fileReader.close();
}
文件内容是：abcdefg 传入字符数组进行读取。
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("abc/1.txt");
char[] arr = new char[3];
int len = fileReader.read(arr);
System.out.println(len);
System.out.println(arr);
System.out.println("-----------");
int len2 = fileReader.read(arr);
System.out.println(len2);
System.out.println(arr);
System.out.println("------------");
int len3 = fileReader.read(arr);
System.out.println(len3);
System.out.println(arr);
System.out.println("------------");
int len4 = fileReader.read(arr);
System.out.println(len4);
System.out.println(arr);
}
输出结果：
3
abc
-----------
3
def
------------
1
gef
------------
-1
gef
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("abc/1.txt");
char[] arr = new char[3];
int len;
while((len = fileReader.read(arr))!=-1){
String s = new String(arr, 0, len);
System.out.println(s);
}
}
输出结果：
abc
def
g
FileWriter
当目的地文件不存在，会自动创建
完成两个文件的内容复制
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("abc/1.txt");
FileWriter fileWriter = new FileWriter("abc/2.txt");
char[] c = new char[1024];
int len;
while ((len = fileReader.read(c)) != -1) {
fileWriter.write(c, 0, len);
}
fileReader.close();
fileWriter.close();
}
BufferedWriter和BufferReader底层是字符数组
将一个文件内容复制到另一个文件的代码。
方案一：
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("abc/1.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("abc/2.txt"));
int len;
while((len = br.read())!=-1){
bw.write(len);
}
bw.close();
br.close();
}
方案二：
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("abc/1.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("abc/2.txt"));
String tmp;
while((tmp = br.readLine())!=null){
bw.write(tmp);
bw.newLine();
}
bw.close();
br.close();
}
InputStream OutputStream(文件复制三种方法)
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("abc/奇怪的知识增加了.jpg");
FileOutputStream fos = new FileOutputStream("abc/lalala.jpg");
int len;
while ((len = fis.read()) != -1) {
fos.write(len);
}
fos.close();
fis.close();
}
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("abc/奇怪的知识增加了.jpg");
FileOutputStream fos = new FileOutputStream("abc/lalala.jpg");
byte[] c = new byte[1048];
int len;
while ((len = fis.read(c)) != -1) {
fos.write(c, 0, len);
}
fos.close();
fis.close();
}
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("abc/奇怪的知识增加了.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("abc/lalala.jpg"));
int len;
while ((len = bis.read()) != -1) {
bos.write(len);
}
bos.close();
bis.close();
}
字节流，字符流的使用场景
拷贝纯文本文件使用字符流，拷贝其他（图片，音频，视频等）使用字节流。
十二、反射
类加载器将 字节码 文件加载到内存中。
那什么时候会加载类呢？【将字节码文件加载到内存中】
【一个类的字节码文件加载到内存中，只会被加载一次】
Class对象的获取方式
第三种方法，有一个小窍门：可以快速获取类的正名。
public static void main(String[] args) throws ClassNotFoundException {
Student s = new Student();
Class clazz1 = s.getClass();//对象使用getClass方法
Class clazz2 = Student.class;//类名.class
Class clazz3 = Class.forName("March.Day14.Student");//Class.forName("...")
System.out.println(clazz1 == clazz2);//true
System.out.println(clazz2 == clazz3);//true
}
反射方式获取构造方法
【最终目的是创建一个对象】
public class Student {
public Student() {
}
public Student(String name) {
System.out.println("这是学生类的有参公共构造函数");
}
private Student(int age) {
}
}
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
Class clazz = Class.forName("March.Day14.Student");//Class.forName("...")
Constructor constructor = clazz.getConstructor();
System.out.println(constructor);
System.out.println(constructor.getName());//Constructor类中getName方法
System.out.println("------------------------------------");
Constructor constructor2 = clazz.getConstructor(String.class);
System.out.println(constructor2);
Student stu = (Student) constructor2.newInstance("张三");
System.out.println(stu);
System.out.println("------------------------------------------");
Constructor constructor3 = clazz.getDeclaredConstructor(int.class);
System.out.println(constructor3);
System.out.println("----------------------------------------");
Constructor[] constructors = clazz.getConstructors();
for (Constructor con : constructors) {
System.out.println(constructor);
}
}
运行结果：
public March.Day14.Student()
March.Day14.Student
------------------------------------
public March.Day14.Student(java.lang.String)
这是学生类的有参公共构造函数
March.Day14.Student@2d98a335
------------------------------------------
private March.Day14.Student(int)
----------------------------------------
public March.Day14.Student()
public March.Day14.Student()
反射方式获取成员方法 并使用
开启暴力反射
开启暴力反射，否则私有方法的method对象不能invoke
method3.setAccessible(true);
代码举例一 获取公共方法、私有方法
Studet类：
public class Student {
public void show1() {
System.out.println("公共的空参方法");
}
public void show2(int a) {
System.out.println("公共的有参方法，你输入的参数是" + a);
}
private int show3(int a, int b) {
System.out.println("私有的带参方法");
return a + b;
}
}
public static void main(String[] args) throws Exception {
Class clazz = Student.class;//获取class对象
Constructor constructor = clazz.getConstructor();//构造器
Student student = (Student) constructor.newInstance();//创建对象
Method method1 = clazz.getMethod("show1");//获取Method对象
System.out.println(method1);//打印这个Method对象
System.out.println(method1.getName());//打印方法名称
method1.invoke(student);//使用对象
System.out.println("------------------------------------");
Method method2 = clazz.getMethod("show2", int.class);
method2.invoke(student, 56);
System.out.println("-----------------------------------");
Method method3 = clazz.getDeclaredMethod("show3", int.class, int.class);
method3.setAccessible(true);//开启暴力反射，否则私有方法的method对象不能invoke
int sum = (int) method3.invoke(student, 4, 6);
System.out.println(sum);
System.out.println("------------------------------------");
Method[] methods = clazz.getMethods();//获取所有的非私有Method对象
for (Method method : methods) {
System.out.println(method);
}
}
运行结果：
public void March.Day14.Student.show1()
show1
公共的空参方法
------------------------------------
公共的有参方法，你输入的参数是56
-----------------------------------
私有的带参方法
10
------------------------------------
public void March.Day14.Student.show1()
public void March.Day14.Student.show2(int)
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
代码举例二 获取setter方法
public class Student {
String name;
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("March.Day14.Student");//获取class对象
Constructor constructor = clazz.getConstructor();//获取constructor对象
Student stu = (Student) constructor.newInstance();//创造对象
Method setName = clazz.getMethod("setName", String.class);//获取method对象
setName.invoke(stu, "mason");//使用方法
System.out.println(stu);//打印结果Student{name='mason'}
}
通过反射获取成员变量并使用
Student类：
public class Student {
public String name;
private int age;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
代码演示：
私有成员变量，如果想改变，需要设置【age.setAccessible(true);】暴力反射
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("March.Day14.Student");//获取class对象
Constructor constructor = clazz.getConstructor();//获取constructor对象
Student stu = (Student) constructor.newInstance();//创造对象
Field name = clazz.getField("name");
name.set(stu, "mason");
Field age = clazz.getDeclaredField("age");
age.setAccessible(true);
age.set(stu, 15);
System.out.println(stu);//Student{name='mason', age=15}
}
1482
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
