java基础知识
{collapse-item label="编写equals和hashCode"}
要正确使用HashMap，作为key的类必须正确覆写equals()和hashCode()方法； 一个类如果覆写了equals()，就必须覆写hashCode()，并且覆写规则是： 如果equals()返回true，则hashCode()返回值必须相等； 如果equals()返回false，则hashCode()返回值尽量不要相等。 实现hashCode()方法可以通过Objects.hashCode()辅助方法实现。
{/collapse-item}
{collapse-item label="instanceof "}
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为： boolean result = objinstanceof Class
{/collapse-item}
{collapse-item label="继承关系"}
当我们判断一个实例是否是某个类型时，正常情况下，使用instanceof操作符
Object n = Integer.valueOf(123);
boolean isDouble = n instanceof Double; // false
boolean isInteger = n instanceof Integer; // true
boolean isNumber = n instanceof Number; // true
boolean isSerializable = n instanceof java.io.Serializable; // true如果是两个Class实例，要判断一个向上转型是否成立，可以调用isAssignableFrom()
// Integer i = ?
Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer
// Number n = ?
Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number
// Object o = ?
Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object
// Integer i = ?
Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer{/collapse-item}
{collapse-item label="访问字段"}
访问字段 Class类提供了以下几个方法来获取字段： Field getField(name)：根据字段名获取某个public的field（包括父类） Field getDeclaredField(name)：根据字段名获取当前类的某个field（不包括父类） Field[] getFields()：获取所有public的field（包括父类） Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）
//1
Class stuClass=Student726.class;
// 获取public字段"score":
System.out.println(stuClass.getField("score"));
// 获取继承的public字段"name":
System.out.println(stuClass.getField("name"));
// 获取private字段"age":
System.out.println(stuClass.getDeclaredField("age"));
//2
Field f=String.class.getDeclaredField("value");Field对象 该对象包含了一个字段的所有信息 一个Field对象包含了一个字段的所有信息： getName()：返回字段名称，例如，"name"； getType()：返回字段类型，也是一个Class实例，例如，String.class； getModifiers()：返回字段的修饰符，它是一个int，不同的bit表示不同的含义。
//1
class Student726 extends Person{
public int score;
private int age;
}
class Person{
public String name;
}
//2
final class String{
private final byte[] value;
}{/collapse-item}
{collapse-item label="printStackTrace()"}
异常都可以调用printStackTrace()方法打印异常栈，这是一个简单有用的快速打印异常的方法。
{/collapse-item} {collapse-item label="BigDecimal"}
//可以表示一个任意大小且精度完全准确的浮点数
BigDecimal bd1=new BigDecimal("123456.123456789");
System.out.println(bd1.multiply(bd1));//15241414418.977927146750190521
System.out.println(bd1);//123456.123456789
//scale表示小数位数
System.out.println(bd1.scale());//9
//stripTrailingZeros
//可以将一个BigDecimal格式化为一个相等的，
//但去掉了末尾0的BigDecimal
BigDecimal db2=new BigDecimal("123.12300");
BigDecimal db4=new BigDecimal("12300");
BigDecimal db3=db2.stripTrailingZeros();
BigDecimal db5=db4.stripTrailingZeros();
System.out.println(db2+" "+db3);//123.12300 123.123
System.out.println(db2.scale());//5
System.out.println(db3.scale());//3
//如果一个BigDecimal的scale()返回一个负数，例如-2，
//表示这个数是整数，并且末尾还有两个0
System.out.println(db4);//12300
System.out.println(db5.scale());//-2 位数00
//四舍五入或直接截断 setScale格式化小数点
BigDecimal db6=new BigDecimal("456.789");
BigDecimal db7=db6.setScale(2,RoundingMode.HALF_UP);
BigDecimal db8=db6.setScale(2,RoundingMode.DOWN);
System.out.println(db7);//四舍五入 456.79
System.out.println(db8);//直接截断 456.78
//divide表示除数 保留1位小数并四舍五入
//roundingMode表示结果的取值方式
BigDecimal db9=db2.divide(db4,1,RoundingMode.HALF_UP);
System.out.println(db9);
//divideAndRemainder() 返回的数组包含两个BigDecimal
//分别是商和余数，其中商总是整数，余数不会大于除数
//可以利用方法判断两个BigDecimal是否为整数倍数
BigDecimal m1=new BigDecimal("10.5");
BigDecimal m2=new BigDecimal("0.15");
BigDecimal[] m3=m1.divideAndRemainder(m2);
if (m3[1].signum()==0) {
System.out.println("m1是m2的整数倍");
}
//在比较两个BigDecimal的值是否相等时，要特别注意，
//使用equals()方法不但要求两个BigDecimal的值相等，
//还要求它们的scale()相等：
BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("123.45600");
System.out.println(d1.equals(d2)); // false,因为scale不同
System.out.println(d1.equals(d2.stripTrailingZeros())); // true,因为d2去除尾部0后scale变为2
//必须使用compareTo()方法来比较，
//它根据两个值的大小分别返回负数、正数和0，
//分别表示小于、大于和等于。
System.out.println(d1.compareTo(d2)); // 0{/collapse-item} {collapse-item label="BigInteger"}
//BigInteger
//对BigInteger做运算的时候，只能使用实例方法，例如，加法运算：
BigInteger b1=new BigInteger("1234567890");
BigInteger b2=new BigInteger("98765432101");
BigInteger sum=b1.add(b2);
System.out.println(sum);//99999999991
//可以吧BigInteger转换成long类型
System.out.println(sum.longValue());
System.out.println(sum.multiply(sum).longValue());
//使用longValueExact()方法时，
//如果超出了long型的范围，会抛出ArithmeticException。BigInteger和Integer、Long一样，也是不可变类，并且也继承自Number类。因为Number定义了转换为基本类型的几个方法：
转换为byte：byteValue() 转换为short：shortValue() 转换为int：intValue() 转换为long：longValue() 转换为float：floatValue() 转换为double：doubleValue()
因此，通过上述方法，可以把BigInteger转换成基本类型。如果BigInteger表示的范围超过了基本类型的范围，转换时将丢失高位信息，即结果不一定是准确的。如果需要准确地转换成基本类型，可以使用intValueExact()、longValueExact()等方法，在转换时如果超出范围，将直接抛出ArithmeticException异常。
如果BigInteger的值甚至超过了float的最大范围（3.4x1038），那么返回的float是Infinity
{/collapse-item} {collapse-item label="enum枚举类"}
让编译器能自动检查某个值在枚举的集合内，并且，不同用途的枚举需要不同的类型来标记，不能混用
//721_1_1
demo721_1.demo721_1_1 d=demo721_1.demo721_1_1.mon;
if(d==demo721_1.demo721_1_1.sat || d==demo721_1.demo721_1_1.sun){
System.out.println("欢迎");
}else {
System.out.println("走开");
}package bindle;
public class demo721_1 {
//枚举
//721_1_1
public enum demo721_1_1{
sun,mon,tue,wed,thu,frt,sat;
}//编译后跟class没区别
// public final class demo721_1_1 extends Enum{//继承Enum 标记final class
// //每个实力均为全局唯一
// public static final demo721_1_1 sun=new demo721_1_1;
// public static final demo721_1_1 mon=new demo721_1_1;
// public static final demo721_1_1 tue=new demo721_1_1;
// public static final demo721_1_1 wed=new demo721_1_1;
// public static final demo721_1_1 thu=new demo721_1_1;
// public static final demo721_1_1 frt=new demo721_1_1;
// public static final demo721_1_1 sat=new demo721_1_1;
// //private构造方法，确保外部无法调用new操作符；
// private demo721_1_1(){}
// }
}引用类型比较，要使用equals()方法，如果使用==比较，它比较的是两个引用类型的变量是否是同一个对象。因此，引用类型比较，要始终使用equals()方法，但enum类型可以例外。
enum定义的类型就是class，只不过它有以下几个特点： 定义的enum类型总是继承自java.lang.Enum，且无法被继承； 只能定义出enum的实例，而无法通过new操作符创建enum的实例； 定义的每个实例都是引用类型的唯一实例； 可以将enum类型用于switch语句。
enum常量本身带有类型信息，即demo721_1.demo721_1_1.mon类型是demo721_1_1，编译器会自动检查出类型错误。
{/collapse-item}
{collapse-item label="String"}
{tabs-pane label="大小转换"}
String str="你好，HelLo";
//转小写
System.out.println(str.toLowerCase());//结果：你好，hello
//转大写
System.out.println(str.toUpperCase());//结果：你好，HELLO
String str1="HelLo";
str1.indexOf("l");//结果2 第一次出现
str1.lastIndexOf("o");//结果4 最后一次出现
str1.startsWith("ll");//结果false 是否指定的钱缀开始
str1.endsWith("o");//结果true 是否以指定的后缀结束
str1.contains("o");//结果true 是否包含区分大小写{/tabs-pane} {tabs-pane label="忽略大小比较"}
String str1="HelLo";
String str2="hello";
//要忽略大小写比较，使用equalsIgnoreCase()方法。
str1.equalsIgnoreCase(str2);
System.out.println(str1);//结果HelLo{/tabs-pane}
{/collapse-item} {collapse-item label="内部类"}
在Java程序中，通常情况下，我们把不同的类组织在不同的包下面，对于一个包下面的类来说，它们是在同一层次，没有父子关系： java.lang ├── Math ├── Runnable ├── String └── ... 还有一种类，它被定义在另一个类的内部，所以称为内部类（Nested Class）。Java的内部类分为好几种，通常情况用得不多，但也需要了解它们是如何使用的。
{tabs-pane label="内部类"}
//内部类 3-1
demo4_2_2 ou=new demo4_2_2("lq");//实例化一个ou
demo4_2_2.demo4_2_2_1 ouset=ou.new demo4_2_2_1();//实例化一个ouset
ouset.getName();//内部类3-1
class demo4_2_2{
//内部类 3-1
private String name;
demo4_2_2(String name){
this.name=name;
this.Name=name;//这是静态的内部类
}
//内部类 3-1
class demo4_2_2_1{
void getName(){
System.out.println("这是内部类 你好,"+demo4_2_2.this.name);
}
}
}{/tabs-pane} {tabs-pane label="匿名内部类"}
//内部类 3-1
demo4_2_2 ou=new demo4_2_2("lq");//实例化一个ou
//匿名内部类 3-2
ou.demo4_2_2_2();//内部类3-1
class demo4_2_2{
//内部类 3-1
private String name;
demo4_2_2(String name){
this.name=name;
}
//匿名类 3-2
void demo4_2_2_2(){
//Runnable本身是接口，接口是不能实例化的，所以这里
//是定义了一个实现了Runnable接口的匿名类，通过new实例化该匿名类
//然后转型为Runnable，在定义匿名类的时候就必须实例化它，写法如下
Runnable r=new Runnable(){
@Override
public void run(){
System.out.println("这是匿名内部类 你好,"+demo4_2_2.this.name);}
};
new Thread(r).start();
}
}{/tabs-pane} {tabs-pane label="静态内部类"}
//静态内部类3-3
//static修饰
demo4_2_2.demo4_2_2_3 sn=new demo4_2_2.demo4_2_2_3();//实例化
sn.hello();//内部类3-1
class demo4_2_2{
private static String Name;
//静态内部类3-3
static class demo4_2_2_3{
void hello(){
System.out.println("这是静态内部类 你好,"+demo4_2_2.Name);
}
}
}{/tabs-pane}
{/collapse-item}
{collapse-item label="抽象类abstract"}
抽象类本身被设计成只能用于被继承，因此， 抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错。 因此，抽象方法实际上相当于定义了“规范”。
chou s=new chou2();
chou w=new chou3();
w.run();
s.run();abstract class chou{
public abstract void run();
}
class chou2 extends chou{
@Override
public void run(){
System.out.println("子类自动跑酷1");
}
}
class chou3 extends chou{
@Override
public void run(){
System.out.println("子类自动跑酷2");
}
}{/collapse-item}
{collapse-item label="多态跟构造"} 多态具有一个非常强大的功能，就是允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。
//多态 构造
//覆写
Student2 s=new Student2("123");
s.run("123213");
System.out.println(s.ceshi());//继承中的覆写
class Student{
protected String name="多态";
public void run(){
System.out.println("Student.run1");
}
public String ceshi(){
return "我是父类super"+name+" ";
}
}
//extends 继承方法的关键字
class Student2 extends Student{
@Override
public String ceshi(){
//System.out.println("System.run");
return super.ceshi()+"子类调用父类";
}
//方法名相同，方法参数相同，但方法返回值不同，
//也是不同的方法。在Java程序中，出现这种情况，编译器会报错。
public void run(String name){
System.out.println(name);
}
//构造方法
public Student2(){
System.out.println("我是空的");
}
public Student2(String name){
this();
System.out.println(name);
}
}{/collapse-item}
{collapse-item label="构造方法"} 每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
this:看上去用来区分局部变量和成员变量的同名的情况 this：就是代表本类对象，this代表它所在函数（方法）所属对象的引用 构造函数之间的调用只能通过this语句来完成 构造函数之间进行调用时this语句只能出现在第一行，构造方法要先执行，如果初始化当中还有初始化，那就去执行更细节的初始化
package demo1;
public class Puppy{//这是一个类
int puppyAge;
//对象1
public Puppy(String name){//创建一个对象 这是类中的一些对象 对象
// 这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
//对象2 方法
public Puppy(String name,int age)
{
System.out.println("小狗的名字是 :"+name+"小狗的年龄为 : " + age );
}
public void setAge( int age ){//都是方法
puppyAge = age;
}
public int getAge( ){
System.out.println("小狗的年龄为 : " + puppyAge );
return puppyAge;
}
public static void main(String[] args){
/* 创建对象 */
Puppy myPuppy = new Puppy( "tommy",123 );
/* 通过方法来设定age */
myPuppy.setAge( 2 );
/* 调用另一个方法获取age */
myPuppy.getAge();
/*你也可以像下面这样访问成员变量 */
System.out.println("变量值 : " + myPuppy.puppyAge );
}
}{/collapse-item} {collapse-item label="创建对象"} 对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步： 声明：声明一个对象，包括对象名称和对象类型。 实例化：使用关键字 new 来创建一个对象。 初始化：使用 new 创建对象时，会调用构造方法初始化对象。
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public static void main(String[] args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( "tommy" );
}
}{/collapse-item}
{collapse-item label="访问控制修饰符"} Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。 default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。 private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类） public : 对所有类可见。使用对象：类、接口、变量、方法 protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。 {/collapse-item} {collapse-item label="非访问修饰符"} 为了实现一些其他的功能，Java 也提供了许多非访问修饰符。 static 修饰符，用来修饰类方法和类变量。 final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。 abstract 修饰符，用来创建抽象类和抽象方法 synchronized 和 volatile 修饰符，主要用于线程的编程。 {/collapse-item}
{collapse-item label="StringBuilde类 字符串修改"} 在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。 StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）
//StringBuilder类 字符串修改
StringBuilder sb = new StringBuilder(10);
sb.append("Runoob..");
System.out.println(sb);
sb.append("!");
System.out.println(sb);
sb.insert(9, "Java");
System.out.println(sb);
sb.delete(5,6);//删除 >=5 小于6的下标字符
System.out.println(sb); {/collapse-item} {collapse-item label="其他"} import java.util.*; 所有的包 输入输入:Scanner 扫描仪 import java.util.Scanner; 导入扫描仪包 例如：Scanner i=new Scanner(System.in) 数据类型：Boolean String int double char
//SecureRandom //有伪随机数，就有真随机数。 //实际上真正的真随机数只能通过量子力学原理来获取， //而我们想要的是一个不可预测的安全的随机数， //SecureRandom就是用来创建安全的随机数的 SecureRandom sr1=new SecureRandom(); System.out.println(sr1.nextInt(10));
运算符的优先级：逻辑运算符只能对Boolean类型的数据进行操作 字符串之间进行比较要用 equals 进行对比 不能用 ==
Switch： Switch（参数1）{ Case 值1：输出语句 break； Case 值2：输出语句 break； Default：输出语句 }
随机数 random Random XX=new Random(); int number=ii.nextInt(10);//0~9 int number2=(int)(Math.random()*10)//同上
循环for for(初始参数1;变量参数2;参数3){} 初始参数1代表循环的初始值，可以定义多个参数， 变量参数2代表循环的次数，也可以为多个参数， 参数3 代表每次循环后所增减的值 注释：For里面也可以进行break语句
Java作为一种面向对象语言。支持以下基本概念：多态、继承、封装、抽象、类、对象、实例、方法、重载 • 对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。 • 类：类是一个模板，它描述一类对象的行为和状态。
{/collapse-item}
{collapse-item label="数组"}
//java数组
//数组的定义写法
int[] aa;
int aaa[];
//设置数组的大小
int[] aa1=new int[5];
int aa2[]=new int[5];
//固定的值
int[] aa3={1,2,4,5,6,3,2};
//foreach的写法
for(int e:aa3){System.out.print(e);}
System.out.println("请输入循环多少次：");//设置数组大小跟循环的次数
int count=i.nextInt();
double[] alist=new double[count];//定义数组的大小
double sum=0,age=0;
for(int q=0;q{/collapse-item}
{collapse-item label="多维数组"}
System.out.println("请输入多维数组行数：");
int d1=i.nextInt();
System.out.println("请输入多维数组列数：");
int d2=i.nextInt();
String str[][]=new String[d1][d2];//2位行数，3位列数 必须都为整数
//从最高维开始分配空间
for(int q=0;q{/collapse-item}
{collapse-item label="时间SimpleDateFormat 格式化日期"}
SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
System.out.println("当前时间为: " + ft.format(dNow));{/collapse-item}
{collapse-item label="三元运算符"}
由?:符号表示的，具体的含义其实就和if-else结构的含义差不多，这种运算符会将某个条件作两种处理，如果满足条件的话就执行第一个结果，如果不满足的话就执行另外一个结果
//java 三元运算符
int a,b,c;
a=3;
b=2;
c=a>b ? 100:300; //如果a大于b 就将100赋值给c否则就将300赋给c
System.out.println(c);{/collapse-item}
本文共 3402 个字数,平均阅读时长 ≈ 9分钟
腾讯云开发者
