ob几句，今天天气真好，可惜没人陪我呀，只能默默抱起Java书，痛苦的遨游在知识的海洋。
Import:
调用另一个包的类：
① A调用W包中的Y类，则在A中通过W.Y引用Y类
② 通过import关键字：import x.xx… .className,x.xx…表示className这个类所属的包
③ Import x.xx… .,导入包中所有类
由于java.lang的类经常使用。如System、String、Math等。因此Java默认导入java.lang.
Import static:专门用于导入其他包的类中可以直接供用户调用的变量或者方法，这种变量和方法必须是static类型的变量和方法才可以导入。
Import static x.xx… .className.variableName|methodName;
方法的重载：构造方法的重载和方法的重载
方法重载：Java要求方法名相同、方法的参数列表不同即可，这里参数列表不同包括参数的个数不同、参数的数据类型不同、参数的排列顺序不同。
方法重写：重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。这实例对象仍属于父类类型，但是调用方法时，如果这个方法被子类重写，则调用子类中重写的方法，运行多态情况下，父类对象会将子类中重写的方法当自己的方法，而自身被重写的方法不再被调用，即父类反向继承。
参数个数可变方法：允许方法声明时不确定指定参数的个数，但数据类型必须一致
returnType methodNames(paramList1,paramType…variableParamName){
Statements;
}
eg:public double computeSum(double x,double…otherNumbers){}
递归方法:
//n的阶乘
public int Factorial(int n){
if(n1)
return 1;
else if(n>1){
return n*Factorial(n-1)
}
else
return 0;
}
//求整数1~n的和
public int Sum(int n){
if(n1)
return 1;
else if(n>1){
return n +Sum(n-1);
}
else
return 0;
}
//求斐波那契数列的第n项
public int Fibonacci(int n){
If(n1||n2)
return 1;
else if(n>=3){
return Fibonacci(n-1)+Fibonacci(n-2)
}
else
Return 0;
}
封装、继承、多态
封装:
继承:
Java中的继承通过extends关键字完成，与C++的多重继承不一样，Java是单继承模式，即子类只能有一个直接的父类。继承是具有传递性的，在Java中一切类都是Object类的子类。如果子类中需要调用父类中被重写的方法，或者调用父类中被隐藏的变量，或者调用父类的构造方法，则需要使用super关键字进行引用。
多态:
Java中的多态包括运行时多态和编译时多态。方法重载和重写属于编译时多态，运行时多态主要表现在可以通过父类声明一个实例对象，而在初始化对象时，调用子类的构造方法操作。
static（斜体）和final（粗体）
设置一个类的类变量为常数，则可以用static和final修饰符联合起来修饰，此时为类常量，一般为大写，粗斜体。
static是静态修饰关键字，可以修饰变量和程序块以及类方法：
当定义一个static的变量的时候jvm会将将其分配在内存堆上，所有程序对它的引用都会指向这一个地址而不会重新分配内存；
当修饰一个程序块的时候(也就是直接将代码写在static{…}中)时候，虚拟机就会优先加载静态块中代码，这主要用于系统初始化；
当修饰一个类方法时候你就可以直接通过类来调用而不需要新建对象。
final可以修饰变量、方法及类：
当定义一个final变量时，jvm会将其分配到常量池中，程序不可改变其值；
当修饰一个方法时，该方法在子类中将不能被重写；
当修饰一个类时，该类不能被继承。
static变量
按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
static方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
抽象类和接口
抽象类:abstract修饰符用于修饰类和方法，extends继承
接口(Interface):接口通过Interface关键字进行定义，接口中的方法都用public abstract修饰符修饰。除了常量、抽象方法和内部类外，接口不允许有其他的成员存在，甚至连构造方法和初始化块也不允许存在。接口只能继承接口，不能继承类，某个类如果要实现接口，需要类声明时通过implements关键字声明。
Java字符串
（1）String字符串：不可变字符串，一旦声明某个String类型的实例对象，并给该对象赋值后，对象内部的值和长度不能再发生改变，除非为该实例对象重新赋值。
（2）StringBuffer字符串:可变字符串，创建实例对象后，不需要为该实例对象重新赋值，即可直接改变该实例对象的内容。
（3）StringBuilder字符串
StringBuilder和StringBuffer之间的最大不同在于StringBuilder的方法不是线程安全的（不能同步访问）。由于StringBuilder相较于StringBuffer 有速度优势，所以多数情况下建议使用StringBuilder类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
装箱、拆箱
基本数据类型及其对应的包装类:
int a = 100;
int b = 100;
//手动装箱，通过构造方法
Integer c = new Integer(a);
Integer d = new Integer(b);
//手动装箱，通过valueOf方法，对于-128~127的数字在内存中是复用的
c = Integer.valueOf(a);
D = Integer.valueOf(b);
//自动装箱
c = 120;
d = 120;
//手动拆箱
int e = c.intValue();
double f = d.doubleValue();
//自动装箱，自动拆箱
c = 12;
d = 12;
e = c;
f = d;
说明:
① 手动装箱可以通过调用包装类的构造方法进行，将待装箱的基本数据类型变量作为构造方法的参数。
② 手动装箱可以通过调用valueOf方法进行，将待装箱的基本数据类型变量作为方法的参数。
③ 自动装箱时直接将基本数据类型的值赋给对应的包装类实例对象。
④ 手动拆箱通过xxxValue方法完成，xxx指某种基本数据类型。
⑤ 自动拆箱直接将包装类的实例对象赋给对应基本数据类型的变量。
⑥ 可以通过包装类的类常量MAX_VALUE和MIN_VALUE输出个包装类的最大值和最小值。
数字-字符串转换
（1）字符串转换为数字，通过包装类的valueOf方法和paresXxx方法，Xxx指希望转换的基本数据类型。
（2）数字转换为字符串，通过String类的valueOf方法。valueOf方法不仅可以将数字转换为字符串，也可以将字符数组转换为字符串。
Java集合
（1）迭代器（Iterator）：迭代器接口是Java集合框架的组成部分，其主要用途不在于存储数据，而在于遍历数据，创建Iterator的实例对象来完成操作。初始化Iterator实例对象的过程并不由Iterator接口完成，而是需要使用Iterator进行数据遍历的集合，通过调用iterator方法进行的。
（2）ArrayList列表：
package test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class test1 {
public static void main(String[] args) {
// 创建一个list列表，通过ArrayList初始化，该列表中存放Integer对象
List<Integer> list = new ArrayList<Integer>();
//通过add方法添加Integer对象
list.add(1);
list.add(2);
list.add(2);
list.add(2);
list.add(3);
list.add(4);
list.add(2);
list.add(2);
list.add(2);
list.add(6);
list.add(2);
//创建list的Iterator迭代器it
Iterator<Integer> it = list.iterator();
//遍历list，并将其中的内容为2的元素删除
//迭代器it指向对象的上一个地址，需要用next()
while(it.hasNext())
if (it.next().equals(2))
it.remove();
//遍历并输出list列表
it = list.iterator();
System.out.println("通过迭代器输出list列表");
while(it.hasNext())
System.out.print(it.next()+" ");
//通过for循环遍历并输出list列表
System.out.println("\n通过for循环输出list列表");
for(int i = 0;i<list.size();i++)
System.out.print(list.get(i)+" ");
//清空list列表
list.removeAll(list);
System.out.println("\nnow the list size = "+list.size());
//重新添加
list.add(1);
list.add(2);
list.add(2);
list.add(2);
list.add(3);
list.add(4);
list.add(2);
list.add(2);
list.add(2);
list.add(6);
list.add(2);
//从list列表删除内容为2的元素
for(int i = 0;i<list.size();i++) {
if ((int)list.get(i)==2) {
list.remove(i);
i = i-1;
}
}
//遍历输出列表
it = list.iterator();
System.out.println("通过迭代器输出list列表");
while(it.hasNext())
System.out.print(it.next()+" ");
}
}
代码说明:
① 由list接口创建list，通过ArrayList进行实例化，方便以后改，比如使用LinkedList实例化，只需改ArrayList，这些类都是实现list接口的，相应方法也都源于list接口。表示泛型，指定list列表的元素都为Integer类型的。
② 列表添加数据用add方法。
③ 通过Iterator it = list.Iterator();创建list的迭代器。
④ 迭代器初始值是指向list列表的第一条记录的前一个位置，用hasNext方法进行判断下一条是否存在。
⑤ 迭代器通过remove方法删除list列表中最后一次通过next方法指向的位置。
⑥ 程序通过迭代器、for循环和foreach循环输出列表。
⑦ 列表通过get方法获取指定下标的元素。
⑧ 如果不用迭代器，通过list本身删除数据，删除第i条后，列表长度减一，第i+1变成了第i，所以需要i = i-1。
⑨ 创建ArrayList，如果不指定容量，默认容量为10，当超过时，会自动扩容。
Java时间类
处理时间的类Calendar类，Canlendar是一个抽象类，无法通过构造方法来产生时间的实例对象，实际中经常用getInstance方法返回一个时间的实例对象，或者直接使用Calendar类的子类GregorianCalendar类。
Calendar cal = Calendar.getInstance();
int year = cal.get(Calendar.YEAR);//取得当前年份
Int month = cal.get(Calendar.MONTH)+1;取得当前月份，月份从0开始要加1
sdf.applypattern(“yyyy-MM–dd”);//重新设置时间格式
注意在时间转换中当天数大于25天转换后的毫秒大于int范围，所以需要类型转换为long
作者：抱正远大的年
来源：CSDN
原文：https://blog.csdn.net/qq_40552268/article/details/88933483
版权声明：本文为博主原创文章，转载请附上博文链接！
7987
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
