1、不同的包package下的类名可以相同
2、标识符：类名，不能以数字开头，区分大小写。字母、数字、下划线、美元符号组成的标志符。不能有空格。
3、变量名：驼峰命名、类名命名时首字母都大写。
4、浮点型：可以存储有小数位的值。
分为单精度浮点型float和双精度浮点型double
float a=12.123f
double b=12.1234
单精度浮点型赋值时后面要加f，双精度的不需要。
单精度浮点和双精度浮点的区别是：
单精度浮点在内存中占8位字节，双精度浮点占16位字节。
单精度浮点的运算速度更快，双精度的较慢些，都能存储小数值的数。
5、字符型：利用Ascii码值可以从整型换成字符型
char ch=65；65代表的是字母A
超过65535就不能解析成字符型了，需要强制类型转换成字符。
定义字符型时需要用单引号括起来。
定义字符串时需要用双引号括起来。
6、如果A类型的数据表示范围比B类型大，则将A类型的值赋值给B时，需要进行数据类型转换。
image.png
7、final定义的常量定义名称时用大写字母
8、运算符：
赋值运算符 =
关系运算符 大于号、小于号
逻辑运算符 && || 并、非
赋值运算符：
等于号就是赋值运算符。
X + = 5
就是指X=X+5 先计算x+5然后赋值给x。
num=num++ num先赋值给num然后再加1。
num=++num 先num加1然后再赋值给num。
int x=4;
int y=(x++)+5;
运行之后y=9，x=5
x先赋值给x参与运算后再加1。
int y=(++x)+5;
运行之后y=10,x=5
x先加1然后参与运算。
逻辑运算符：
&&且运算符、 ||或运算符是短路运算符，通过第一个表达式就能判断出来是false的话后面的表达式就不再判断了
！逻辑非运算符。
条件运算符：
单目运算符是指对一个变量运算，比如++
双目运算符是需要对两个变量运算，比如+—*
条件运算符是一个三目运算符
c=a>b?a:b;
如果a>b则把a的值赋给c，否则把b的值赋给c。
image.png
运算符优先级：
image.png
9、三大流程控制语句
顺序、选择、循环
switch（表达式） case后面的表达式必须是常量，比如是数字。jdk8.0case后面的表达式可以是字符型的。
char类型的变量可以参与运算。
image.png
break语句结束循环体，循环不再进行。
continue语句结束当前循环，continue下面的语句不再执行，但是整个循环仍会继续，继续下一次循环。
10、java方法：
冒泡排序算法：
循环比较大小，替换值。
基本数据类型传值不会改变变量值。
引用数据类型比如数组传值是会改变的数组中的值，因为数组传过去后在内存中是同一片内存，所以改的是同一个地方，基本数据类型的值指向不同的内存地址，所以不会改变值。
可变参数列表
int ... n
可变参数列表类似数组，传值时（1，2，3，4）
一个方法的入参如果有可变参数列表也有其他参数，可变参数列表一定要放到最后。
可变参数列表如果在重载方法中，那有可变参数的方法不会被优先执行。会优先执行其他的方法。
文档注释/** */ 前面有两个星号。
11、arraylist和linkedlist的区别：
ArrayList是数组实现的，适合随机查找，根据下标随机查找
LinkedList是基于链表实现的，适合随机增加删除元素
就像我要在List的第五个位置增加一个元素或者删除一个元素，这种操作LinkedList更适合一些
如果要直接找第5个元素这种操作 ArrayList更适合一些 ArrayList支持随机访问
LinkedList需要从第一个元素一个一个的找，
这是它俩的最根本区别
ArrayList和Vector最本质区别是ArrayList不是线程安全的Vector是线程安全的。
最简单的链表就是单链表，有个头节点，头节点里有个指向下一个节点的指针
每个节点都有一个指向下一个节点的指针
所以如果要查找链表当中的某一个元素必须从头开始，一个一个的找
链表增加或删除元素的时候，只需要更改指针的指向就可以了
set适合查找、arraylist适合增加，增加时直接增加到尾部。
12、类中的变量叫成员属性，不赋值程序也会给他初始化。
方法中的变量不赋值就会提示没初始化。
13、声明对象、实例化对象、将声明的对象指向实例化对象的内存空间。new几个就开辟了几个内存空间。声明两个对象都指向同一个实例化对象，那这两个对象在内存中的地址也不相同。
image.png
Cat one=new Cat（）；
Cat two=new Cat（）；
one和two因为在内存中位置不同所以对象不同。
Cat one=new Cat（）；
Cat two；
one=two，那么就相等了。
14、当没有构造方法时会自动添加一个无参的构造方法，当有构造方法不管有参数还是无参数系统都不会自动添加，一个类中可以有多个构造方法。
15、this关键字在类中就代表是当前类的对象，可以通过this访问当前类的成员属性、成员方法和构造方法，this（）就可以代表调用了构造方法。this.name就代表调用了当前类的成员属性。
image.png
16、代码块
大括号括起来的代码块放到方法中叫普通代码块。
放到类中叫构造代码块。
前面加static叫静态代码块。
image.png
17、继承：父类不可以访问子类特有的属性和方法，子类可以访问父类非私有的属性和方法。私有的private的不行。
在子类中可以通过this.属性，this.方法（）去访问父类中的属性和方法。
this其实就是父类的对象。类的对象。
18、方法重载：1、同一个类中 2、方法名相同，参数不同（参数类型不同、参数顺序不同、参数个数不同）
其中public void test(int month,string name)与public void test(int name,string month)不是重载的关系，因为重载与参数名没关系与参数类型有关系。
方法重写：在继承关系中子类重写父类的方法，方法名要相同、参数要相同（参数类型、参数顺序、参数个数）都要相同，重写的方法中可以写字类特有的逻辑。调用时调用字类重写的方法不再调用父类的方法。
19、访问修饰符：
public公共
private私有的 只在本类中访问
protected受保护的 本类可以访问、子类可以访问、其他类如果在同一个package包中可以访问，在不同包不可以访问。
默认：就是什么都不加的，在同一个包中子类和非子类可以访问，在不同包中子类和非子类都不可以访问。
访问权限：
public>protected>默认>private
20、super关键字是用在子类中，super代表父类的对象，可以用super.属性，super.方法（）直接在子类中调取父类的属性和方法。在主方法main类中，实例化子类对象后，通过子类对象也能直接调用父类的属性和方法。
子类在实例化的过程中是需要调父类的无参构造方法的，所以父类的无参构造方法一定要写。有参构造方法都不会调用。
super后面带括号是代表调父类的构造方法，即super()
必须放在子类构造方法里的第一行，如果调用父类的有参构造方法，需要在super()中添加参数，比如super（name，sex）。
如果不加super（）默认调用父类的无参构造方法。
image.png
image.png
image.png
21、object类中equals方法比较的是两个对象指向的是不是同一个引用
如果重写了equals方法则比较的是对象的值而不是引用的内存空间。
==双等于比较的也是两个对象的引用地址而不是值。
22、final关键字
在类中，public final class classname（）代表该类不能被继承。
在方法中，public final void defname（）代表该方法不能被继承不能被重写，但是能被调用。
在局部变量中 final String name 可以在定义时赋值也可以在使用前赋值，只能赋值一次。
在成员属性前加final 可以在定义时赋值，也可以在构造代码块中赋值，或者构造函数中赋值，不能在其他地方赋值。
23、多态
比如有一个打印机是父类A，有两个子类，分别是打印机打印黑色纸B，打印机打印彩色纸C，父类有一个打印的方法，B和C两个子类继承父类A，都重写打印的方法，分别打印黑色纸和打印彩色纸。
A a1=new B();
A a2=new C();
a1调用打印方法，其实调用的是B类中打印黑色纸的打印方法；a2调用打印方法，其实调用的是C类中打印彩色纸的打印方法。
这种形式就是java多态，声明一个父类对象可以有多个子类来实现，从而实现多种方法。
Animal animal=new Cat();
animal可以调用子类重写的父类方法和父类派生出的方法，但是不能调去子类自己的方法。
父类对象子类来实例化，向上转型。
向下转型，子类对象 父类来实例化，必须强制转换成子类才行。
Cat cat=（Cat）animal；
这样可以调用子类特有的方法。
向下转型时需要用instanceof关键字来判断是否包含要转型的类型。
if(animal instanceof cat){
Cat cat=（Cat）animal；}
不包含的话就算代码写着没错编译时也会报错的。
同时animal instanceof Animal,animal instanceof Object结果都为true，是具有这些类的特性的。
24、abstract 修饰符放在public后 定义一个抽象类，该类一般去定义父类 代表父类不能被实例化，定义父类的实例化是没有意义的，因为真正实现的方法都在子类中。真要实例化可以通过向上转型就是父类引用指向子类实例化 Animal animal=new Cat（）
定义抽象方法时可以不写方法体、抽象方法必须被子类重写，有抽象方法的类一定是抽象类，有抽象类不一定有抽象方法。
子类如果不重写父类的抽象方法则会编译失败。
24、interface 创建接口 实现接口在类后面加implement 接口名
接口中定义方法可以不实行方法体，在实现类中再实现方法体。
接口可以指向实现接口的类实例化但是不能调用实现接口的类中的方法。
比如iphone是接口，定义了phone方法，ios、android是两个实现接口的类
iPhone phone =new ios();
iPhone phone2=new android();
phone.phone（）；调用ios类中写重写的phone方法
phone2.phone（）；调用android中重写的方法
接口和实现接口的类只是建立了关系但是不能调用实现类中的方法。
25、jdk1.8以上可以在接口中写默认的方法和静态的方法，默认的方法和静态的方法中可以写方法体，默认的方法可以被子类重写，静态的方法不可以被子类重写只能被子类通过接口名.super.静态方法名（）去调用。
默认的方法：
default void demo1(){
编写方法体｝
静态的方法：
static voiddemo2(){
编写方法体｝
26、如果一个类D继承父类A，继承B和C两个接口，A、B、C中都有重复的属性和方法，则D调用这个重复的属性时
27、成员内部类、方法内部类、静态内部类、匿名内部类
28、异常：
image.png
29、System.exit（1）；退出当前程序
后面的程序不再执行
finaly中不能有return关键字 要不然try和catch中的return关键字执行后也会被finaly中的return关键字给覆盖。
30、包装类
image.png
31、==和equals的区别：
==比较地址，equals比较内容
image.png
32、线程：
可以用继承Thread类的方式实现继承，也可以使用implement runnable的方式实现继承，用第二种实现runnable接口的方式比较多，因为实际环境中一个类只能继承一个父类却可以实现多个接口，所以不能再继承Thread类而要通过实现Runnable接口来创建线程。
image.png
线程的生命周期：
image.png
1、线程总共有5个状态：new新建、可运行runnable、正在运行running、阻塞Blocked、终止Dead
2、new Thread新建，创建线程对象，调用start()方法变成可运行runnable状态；新建的线程对象，调用stop()方法变成终止Dead状态
3、可运行runnable状态获取cpu使用权后变成正在运行running状态；调用stop()方法变成Dead终止状态
4、正在运行running状态线程执行完毕或异常终止，或者调用stop()方法变成终止Dead状态；正在运行running状态调用join()、wait（）、sleep（）、I/O请求线程变成阻塞Blocked状态；正在运行的线程当时间片用完或者调用yieId()方法线程变成可运行Runnable状态
5、阻塞Blocked调用stop()方法线程变成终止Dead()状态；等待调用join()的线程执行完毕、notify()或notifyAll()、sleep超时、I/O请求完成线程变为可运行Runnable状态。
线程总结：
1、线程有两种实现方法，继承Thread类和实现Runnable接口，实现Runnable接口的方式比较常用，因为写程序时一个类只能继承一个父类，就不能继承Thread类但是接口却能实现多个。不管用哪种方式都要在线程类中实现run方法，线程执行的方法。
2、thread对象.start()方法启动线程
3、调用线程的sleep方法，使正在运行的线程进入阻塞状态，当时间结束后线程变成可运行状态，当获取cpu的使用权后会继续运行
所以sleep方法只是让线程休眠一段时间。
4、调用join()方法，让线程抢先执行，只有该线程执行完后才能执行其他线程；join(long millions),join方法中加入时间，在设置的时间内如果该线程没有执行完，其他线程会开始执行；join(long millions),join方法中加入时间，在设置的时间内如果该线程已经执行完，也会立刻执行其他线程
5、线程的优先级：最高级是10，最低级是1，默认级别是5，级别越高越抢先执行；设置线程级别setPriority(Thread.MAX_PRIORITY);setPriority(Thread.MIN_PRIORITY);
6、synchronized关键字，保证方法被当前线程执行时先锁定，不被其他线程打断，保证程序执行的完成性。
可以在声明方法时加，也可以在方法中加，synchronized(this)，this就代表的当前类
意思就是同时在操作当前类时，当前的方法被锁定，只能有一个线程去执行，执行完了才能有其他线程去执行。
7、notifyAll();//notifyAll()方法是释放线程资源，不然消费者会等生产者，生产者会等消费者，出现互相等待的情况
33、输入输出流：
分为字节输入输出流和字符输入输出流。参数分别为byte和char类型的数组。
字节输入流InputStream：重点讲文件输入流FileInputStream，缓冲输入流BufferedInputStream，对象输入流ObjectInputStream
字节输出流OutputStream：重点讲文件输出流FileOutputStream，缓冲输出流BufferedOutputStream，对象输出流ObjectOutputStream
缓冲输出流中flush方法：
为什么要调用flush方法，因为输出流在进行输出时，比如像某个文件中写入内容，其实是先将输出流写入到缓冲区，
当缓冲区写满后才将缓冲区的内容输出到文件中。但是当主机完成输出流的输出后，有可能缓冲区这个时候还没有被填满，
这样的话，就会一直等待主机发送内容，这时候，就可以使用flush将缓冲区的内容强制输出到文件中，清空缓冲区。
所以，一般在关闭输出流之前，要先调用flush方法强制缓冲区中的内容输出，并清空缓冲区
字符输出流：InputStreamReader、OutputStreamWriter，可以结合缓冲流BufferedReader、BufferedWriter一起使用。使用字符输出流之前可以先用文件输入流导入文件中的数据就是FileInputStream、InputStreamReader、BufferedReader读取数据，FileOutputStream、OutputStreamWriter、BufferedWriter写入数据。
文件字节输入流和文件字节输出流：FileInputStream、BufferedInputStream、FileOutputStream、BufferedOutputStream。
34、extends和implement
extends继承父类 只能继承一个父类
implement是实现接口，一个接口可以被多个类实现，一个类也可以实现多个接口，用逗号隔开。
35、接口和抽象类的区别：
image.png
36、排序：
数组排序用Arrays.sort()方法；
list排序用Collections.sort()方法;
list中的类型是无法排序的对象，需要对该对象类实现Comparable接口，重写compareTo方法
public class Student implements Comparable<Student>{
//自定义排序规则，根据该类中的id属性排序
@Override
public int compareTo(Student o) {
return this.id.compareTo(o.id);
}
}
排序时优先排序数字，然后是大写字母，最后是小写字母。
也可以实现Comparator接口重写compare方法
//实现Comparator接口
public class StudentComparator implements Comparator<Student> {
//根据name排序
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
}
public void testStudentList(){
List<Student> studentlist=new ArrayList<>();
Random random=new Random();
studentlist.add(new Student(random.nextInt(1000)+"","yit"));
studentlist.add(new Student(random.nextInt(1000)+"","suny"));
studentlist.add(new Student(random.nextInt(1000)+"","qinz"));
System.out.println("--------------排序前--------------------");
iteratorList(studentlist);
//实现Comparable接口重写compareTo方法进行排序
// Collections.sort(studentlist);
// System.out.println("--------------排序后--------------------");
// iteratorList(studentlist);
//实现Comparator接口重写compare方法进行排序
Collections.sort(studentlist,new StudentComparator());
System.out.println("--------------排序后--------------------");
iteratorList(studentlist);
}
image.png
网友评论