1、注释
- 单行注释 //
- 多行注释 /* */
- 文档注释 /** */ （与命令javados -encoding UTF-8 charset UTF-8 a.java 一起使用生成帮助文档）
2、数据类型
- 基本数据类型（8种）：int、short、baty、long、float、double（金融相关的浮点使用BigDecimal）、char、boolean
- 引用数据类型：类、接口、数组
- 1B（byte，字节）=8bit（位）
3、使用Intellij Idea生成JavaDoc文档
参考链接：https://blog.csdn.net/weixin_42140580/article/details/89635775
4、可变参数
一个方法只能定义一个可变参数，并且它必须是最后一个参数
public static void fun（int … num）;
当前fun方法，可接收1个或1个以上的int参数，或直接是int数组
5、增强for循环
for ( 变量类型 变量名 : 数组名 ) {
需要执行的循环语句;
}
5、递归
public static void fun（int n）{
if(n==1){
return 1;
}
else{
return n*fun(n-1);
}
};
6、工具类
-
生成随机数
import java.util.Random; Random r = new Random(); //num的范围为0到a（随机数范围）的值，0<=num<a int num=r.nextInt(a); //num的范围为10到19，10<=num<20 int num=r.nextInt(10)+10; -
键盘录入：Scanner类，用于用户交互
import java.util.Scanner; Scanner sc = new Scanner(System.in); //录入int int num = sc.nextInt(); //录入String String str = sc.next(); -
String
equals(字符串)：比较两个字符串内容是否相同，相同返回true，否则返回false equalsIgnoreCase(字符串)：比较两个字符串内容是否相同，但是忽略大小写 charAt(索引)：返回字符串中指定索引位置的字符，字符串的索引从0开始 toCharArray()：把字符串转成字符数组 length()：返回字符串的长度 split("-")：通过-分割字符串
7、稀疏数组
0 0 0 0 行 列 值
0 0 2 0 [0] 4 3 2 [0]中记录总行数、总列数、有效值个数（0以外的值）
0 0 0 1 [1] 1 2 2 [1][2]...中记录有效值的位置（行数用下标定义，比实际行数少1），
[2] 2 3 1 [1]中表示2在第1行第二列,[2]中表示1在第2行第3列
8、OOP面向对象编程
- 本质：以类的方式组织代码，以对象的方式组织（封装）数据
- 抽象：abstract
- 不能new抽象类，只能子类去实现它
- 抽象类中可以写普通方法
- 抽象方法必须在抽象类中
- 三大特性：
- 封装：get/set
- 继承：extends
- 子类 单继承 父类所有非私有的属性与方法
- 使用this进行调用本类成员属性、成员方法
- 使用supper进行调用父类属性、方法
- 子类构造第一行默认调用父类空参构造super()
- 重写：
- 子类重写父类的非静态的方法，
- 重写后调用重写的方法会是子类的方法
- 子类重写父类方法，方法名、形参列表一致，访问权限大于或等于父类，返回值小于或等于父类
- 多态
- Persion p=new man()； 父类引用指向子类,无法调用子类的独有方法
- 接口：interface
- 一个类可以说实现多个接口
- implement 实现接口
- 实现接口的类，必须实现接口的方法
9、关键字
-
static：
- 修饰的方法与类一起加载，优先级较高；
- 未用static修饰的方式只能通过创建对象调用
- 静态属性会被多个对象共享，即一个对象改变其属性的值，其他对象取的值也会受影响而改变；一般通过 类名.变量名 调用
- 在静态方法中不能直接访问非静态成员
-
private：私有的
-
this关键字：
1、哪一个对象调用方法方法中的this就是哪一个对象
2、在"局部变量"覆盖"成员变量"时，要访问被覆盖的"成员变量"必须使用this访问 -
instanceof：
boolean b = object1 instanceof object2 //当object1 与object2存在继承关系时，结果b为true，否则b为falsh
10、栈和堆
- 栈：存储变量名称，指向堆中的对象、方法
- 堆：存储对象和方法
11、异常处理
-
异常捕获
try{ int a=1/0; }catch(Errer e){ log(e); } catch(Exception e){ log(e); } finally{ log(“最后要执行的事情”); } //try后加上小括号，在其内定义流对象，即可自动释放 try (FileReader fileReader = new FileReader("D/e.txt");){ char[] chars = new char[1024]; int len; while ((len=fileReader.read(chars))!=-1){ System.out.println("chars = " + new String(chars,0,len)); } } catch (IOException e) { e.printStackTrace(); } finally { } -
异常抛出
- throw：用在代码逻辑书写过程中
- throws：用在方法上
-
自定义异常
//自定义异常 public class MyException extends Exception { public MyException(String message) { super(message); } } //调用与抛出 public class Demo { public static void main(String[] args) { saveAge(1111); } private static void saveAge(int age) { if(age<0||age>150){ try { throw new MyException("年龄不合法"); } catch (MyException e) { e.printStackTrace(); } } } }
11、String、StringBuffer与StringBuilder之间区别
| String | StringBuffer | StringBuilder |
|---|---|---|
| String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且浪费大量优先的内存空间 | StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量 | 可变类，速度更快 |
| 不可变 | 可变 | 可变 |
| 线程安全 | 线程不安全 | |
| 多线程操作字符串 | 单线程操作字符串 |
12、lambda 表达式
Student stu1 = new Student("小花", 18, 1);
Student stu2 = new Student("小2", 11, 1);
Student stu3 = new Student("小3", 14, 1);
Student[] stus=new Student[]{stu1,stu2,stu3};
/*//lambda转换前
Arrays.sort(stus, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge() - o2.getAge();
}
});*/
//lambda转换后
Arrays.sort(stus, (o1, o2) -> o1.getAge() - o2.getAge());
System.out.println(Arrays.toString(stus));
lambda表达式的重要特征:
- 使用匿名内部类重写函数式接口（有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。可以在接口上用@FunctionalInterface进行检查，确认是否是函数式接口）时，才可以用lambda表达式进行简化
- IDEA匿名内部类转为lambda表达式快捷键：Alt+Shift+回车
- IDEA将lambda表达式还原成匿名内部类：鼠标移动到lambda表达式上、Replace lambda with anonymous class
- 不需要声明参数类型，
- 一个参数无需定义圆括号，但多个参数需要定义圆括号。
- 如果主体包含了一个语句，就不需要使用大括号。
- 如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。
- 参考链接
13、泛型
-
概念：把具体的数据类型用变量表示
-
作用：提供了编译阶段结束，约束所能操作的数据类型，并自动检查，从而避免因为强转而可能导致的异常
-
泛型类：在类名后面进行添加泛型，在创建对象时确认泛型
public class Student<T>{ private T date; public T getDate() { return date; } public void setDate(T date) { this.date = date; } public void showDate(){ System.out.println("date = " + date); } } public class Demo1 { public static void main(String[] args) { Student<String> student = new Student<>(); student.setDate("小江"); student.showDate(); } } -
泛型接口：在接口名称后面定义泛型<T,K>，实现类实现接口时确认泛型
public interface inter <T,K>{ T getT(T t); void getNum(K k); } public class interImpl implements inter<String, Integer> { @Override public String getT(String s) { return "i am "+s; } @Override public void getNum(Integer i) { System.out.println("i = " + i); } } -
泛型方法：在修饰符后面进行泛型定义，并在形参列表有使用到，在方法调用时进行泛型确认
public class Demo4 { public static void main(String[] args) { MyTest("我是t", 19); } public static <T, K> T MyTest(T t, K k) { System.out.println("t = " + t); System.out.println("k = " + k); return t; } } -
泛型通配符：？代表所有类型
-
泛型的上下限
//设置上限，只能是Animal及其子类，默认为object public static void print(List<? extends Animal> t){ for (int i = 0; i < t.size(); i++) { Animal animal=t.get(i); System.out.println("" + animal.getName()); } } //设置下限，只能是Cat及其父类 public static void print2(List<? super Cat> t){ for (int i = 0; i < t.size(); i++) { Cat animal= (Cat) t.get(i); System.out.println("" + animal.getName()); } } -
泛型擦除：泛型是工作在编译阶段的，JVM加载了class文件运行程序时，就会去掉泛型信息，使用Object或者泛型的上限来代替泛型
-
注意事项：泛型不支持基本数据，只能支持对象类型(引用数据类型)
java 中泛型标记符：
- E - Element (在集合中使用，因为集合中存放的是元素)
- T - Type（Java 类）
- K - Key（键）
- V - Value（值）
- N - Number（数值类型）
- ？ - 表示不确定的 java 类型
- 参考链接：https://www.runoob.com/java/java-generics.html
14、迭代器Iterator
-
迭代器 it 的两个基本操作是 next 、hasNext 和 remove。
-
调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
-
调用 it.hasNext() 用于检测集合中是否还有元素。
-
调用 it.remove() 将迭代器返回的元素删除。
-
Iterator输出集合 sites 中的所有元素
// 引入 ArrayList 和 Iterator 类 import java.util.ArrayList; import java.util.Iterator; public class RunoobTest { public static void main(String[] args) { // 创建集合 ArrayList<String> sites = new ArrayList<String>(); sites.add("Google"); sites.add("Runoob"); sites.add("Taobao"); sites.add("Zhihu"); // 获取迭代器 Iterator<String> it = sites.iterator(); // 输出集合中的所有元素 while(it.hasNext()) { System.out.println(it.next()); } } }
15、API注解
- API注释：
@author 作者名
@version 版本号
@since 最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况 - API生成：
参考链接：https://blog.csdn.net/weixin_46033096/article/details/124473536
16、注解
- 内置注解
@Override //重写
@Deprecated //已过时的
@SuppressWarnings(“all”) //抑制警告 - 元注解
@Target //谁使用
@Retention //什么级别使用（运行|class）
17、类的加载
- 加载：加载class字节码文件到内存中，并在堆中生成一个代表这个类的java.lang.Class对象
- 链接：为类变量（static）分配内存并赋予默认初始值
- 初始化：合并所有类变量的赋值动作与静态代码块中的语句
18、反射
-
Class c=类名.Class
-
Class c=对象名.getClass
-
Class c=Class.forName(类路径)
-
Class c=Integer.TYPE
-
可以通过c进行获取父类类型、对象参数、对象方法、字段、构造器等
Class c=Class.forName("com.example.mytest.ThreadTest");//通过类路径获取Class对象 System.out.println("包名+类名="+c.getName());//获取 包名+类名 System.out.println("类名="+c.getSimpleName());//获取 类名 Field[] field1=c.getFields();//获取public属性 Field[] field2=c.getDeclaredFields();//获取全部属性 for (Field field : field2) { System.out.println("属性"+field); } Method[] method1=c.getMethods();//获取public方法（包括父类） Method[] method2=c.getDeclaredMethods();//获取本类方法 for (Method method : method2) { System.out.println("方法="+method); } Constructor[] constructors1=c.getConstructors();//获取public构造器（包括父类） Constructor[] constructors2=c.getDeclaredConstructors();//获取本类的构造器 for (Constructor constructors : constructors1) { System.out.println("构造器="+constructors); } ThreadTest threadTest=(ThreadTest)c.newInstance();//构造一个对象，本质时调用无参构造器 System.out.println(threadTest); //反射获取一个方法 Method test = c.getDeclaredMethod("test", String.class); test.invoke(threadTest,"小江");//无参时args写null //反射获取一个属性 Field field4=c.getDeclaredField("age");//获取public属性 field4.setAccessible(true);//禁用安全检查，用于修改private属性 field4.set(threadTest,2323); System.out.println(threadTest.getAge());
19、项目打包与发布
1、打包
- 点击 IDEA 右侧的 Maven 点击 claean、install、package
- Build->Build Artifacts…
- 参考链接
2、发布
- 将打包好的包放到*\apache-tomcat-8.5.56\webapps目录下，再启动tomact
20、ArrayList集合
//创建集合，注意：泛型只支持引用数据类型，如果想使用基本数据类型，请使用包装类
ArrayList<String> arrayList=new ArrayList<String>();
//新增数据
arrayList.add("111119");
//将数据添加到指定的索引位置
add(索引, 数据)：
//获取数据，通过索引
arrayList.get(1);
//删除数据，通过索引
arrayList.remove(1);
//对ArrayList进行排序
Collections.sort(arrayList);
//获取集合中数据的个数（集合的长度）
size()：
//注意项目：ArrayList可变长，删除一个后，后面数据会往前移动
ArrayList<String> arrayList=new ArrayList<String>();
arrayList.add("111119");
arrayList.add("222229");
arrayList.add("333339");
arrayList.add("444448");
arrayList.add("555558");
for (int i = 0; i < arrayList.size(); i++) {
if(arrayList.get(i).contains("9")){
arrayList.remove(i);
//ArrayList可变长，删除一个后，后面数据会往前移动，所以i需要--
i--;
}
}
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
21、移位运算符
<<:有符号左移动运算（n左移x位，就是n*2的x次方，例如：3<<2,结果为3*2*2=12）
>>:有符号右移动运算（n右移x位，就是n/2的x次方，例如：-8>>2,结果为-8/2*2=-2）
>>>:无符号右移动运算,高位补0（正数时n右移x位，就是n/2的x次方，例如：8>>>2,结果为8/2*2=-2）
22、权限修饰符
- private < 缺省 < protected < public
- private :只能同类调用
- 缺省：只能同包的类调用
- protected：同包的类、不同包的子类调用
- public：所有
23、接口interface
- 接口中的变量，都是常量（默认被public static final修饰）
- 接口中的方法，都是抽象方法（默认被 public abstract修饰）
- 实现几口关键字implement
- 接口可以多实现
- 继承只能单继承，但可以多重继承
24、switch(表达式)中表达式允许的类型
枚举、char、string、低于或等于int的类型：byte、short、int
25、堆栈
1.方法、变量、对象地址在栈中
2.对象在堆中
扫一扫
40万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
