Java基础知识

public class Dog {
    String breed;
    int size;
    String colour;
    int age;
 
    void eat() {
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
    void name(){
    }
}

2.变量

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

3.对象的创建、实例化、访问

用关键字 new 来创建一个新的对象。

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。

public class Dog{
   public static void main(String[] args){
      // 下面的语句将创建一个Dog对象
      Dog dog = new Dog();
   }
}

二、数据类型

1.引用类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。

2.自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

三、变量类型

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

1.Java 局部变量

局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

2.实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。

3.类变量（静态变量）

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

四、Java修饰符

1.访问控制修饰符

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

访问控制和继承

请注意以下方法继承的规则：

父类中声明为 public 的方法在子类中也必须为 public。

父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。

父类中声明为 private 的方法，不能够被继承。

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：

子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；

子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。

接口及接口的成员变量和成员方法不能声明为 protected。

2.非访问修饰符

（1）static 修饰符，用来修饰类方法和类变量。

静态变量：

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：

static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。

对类变量和方法的访问可以直接用类名访问，无需实例化对象进行访问。

（2）final修饰符

final 变量：

final 变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

final方法

父类中的 final 方法可以被子类继承，但是不能被子类重写。

声明 final 方法的主要目的是防止该方法的内容被修改。

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。、

（3）abstract 修饰符

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象方法

抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract sample();

public class demo1 {

    public static void main(String[] args) {
        demo1.a();
        demo1.b();//类非静态无法调用    错误
        demo1.c();//类非静态无法调用    错误
        demo1.d();
        demo1.e();

        demo1 d = new demo1();
        d.a();
        d.b();
        d.c();
        d.d();
        d.e();
    }
    //静态方法不能使用非静态方法
    int a = 10;//类变量非静态,只能被非静态函数调用
    static int b = 20;//静态类变量可被任意函数调用
    public static void a(){
        a=1;//报错
        b=1;
    }
    public void b(){
        a=2;
        b=2;
    }
    void c(){
        a=3;
        b=3;
    }
    private static void d(){
        a=4;//报错
        b=4;
    }
    protected static void e(){
        a=5;
        b=5;
    }

}

五、循环

1.增强 for 循环

for(声明语句 : 表达式)
{
   //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
      }
}

2.break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

3.continue关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句，不执行功能。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句，不执行功能。

六、Number类与Math类引用于

引用于-菜鸟教程 - 学的不仅是技术，更是梦想！

	方法与描述
	xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。
	compareTo() 将number对象与参数比较。
	equals() 判断number对象是否与参数相等。
	valueOf() 返回一个 Number 对象指定的内置数据类型
	toString() 以字符串形式返回值。
	parseInt() 将字符串解析为int类型。
	abs() 返回参数的绝对值。
	ceil() 返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
	floor() 返回小于等于（<=）给定参数的最大整数。
	rint() 返回与参数最接近的整数。返回类型为double。
	round() 它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
	min() 返回两个参数中的最小值。
	max() 返回两个参数中的最大值。
	exp() 返回自然数底数e的参数次方。
	log() 返回参数的自然数底数的对数值。
	pow() 返回第一个参数的第二个参数次方。
	sqrt() 求参数的算术平方根。
	sin() 求指定double类型参数的正弦值。
	cos() 求指定double类型参数的余弦值。
	tan() 求指定double类型参数的正切值。
	asin() 求指定double类型参数的反正弦值。
	acos() 求指定double类型参数的反余弦值。
	atan() 求指定double类型参数的反正切值。
	atan2() 将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
	toDegrees() 将参数转化为角度。
	toRadians() 将角度转换为弧度。
	random() 返回一个随机数。

        System.out.println(Integer.toBinaryString(16));//二进制
        System.out.println(Integer.toHexString(16));//16进制
        System.out.println(Integer.toOctalString(16));//八进制
        System.out.println(Integer.parseInt("144", 8));//将144（八进制）转换为十进制数
        System.out.println(Integer.valueOf("144", 8));//将144（八进制）转换为十进制数
        System.out.println(Integer.valueOf("144"));//int类型

public class _Math {
    public static void main(String[] args) {
        //以下方法只有Number才能调用
        Double x=6.666;
        Double m=6.166;
        int y =5;
        System.out.println(x.intValue());
        System.out.println(x.compareTo(5.55));
        System.out.println(x.equals(y));
        System.out.println(Math.rint(x));
        System.out.println(Math.rint(m));

        Double a = Double.valueOf(5);
        Float b = Float.valueOf("80");
        Integer c = Integer.valueOf("11",2);//2进制
        System.out.println(a);System.out.println(a.toString());
        System.out.println(b);
        System.out.println(c);
        int e = Integer.parseInt("1100",2);
        System.out.println(e);


         int f = 8;
        System.out.println(Math.log(f));
        System.out.println(Math.pow(2, 3));
    }
}


6
1
false
7.0
6.0
5.0
5.0
80.0
3
12
2.0794415416798357
8.0

七、Character 方法

引用于-菜鸟教程 - 学的不仅是技术，更是梦想！

	方法与描述
	isLetter() 是否是一个字母
	isDigit() 是否是一个数字字符
	isWhitespace() 是否是一个空白字符
	isUpperCase() 是否是大写字母
	isLowerCase() 是否是小写字母
	toUpperCase() 指定字母的大写形式
	toLowerCase() 指定字母的小写形式
	toString() 返回字符的字符串形式，字符串的长度仅为1

八、String方法

引用于-菜鸟教程 - 学的不仅是技术，更是梦想！

	方法描述
	char charAt(int index) 返回指定索引处的 char 值。
	int compareTo(Object o) 把这个字符串和另一个对象比较。
	String concat(String str) 将指定字符串连接到此字符串的结尾。
	boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
	static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。
	static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。
	boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
	boolean equals(Object anObject) 将此字符串与指定的对象比较。
	boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
	byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
	byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。
	int hashCode() 返回此字符串的哈希码。
	int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
	int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
	int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
	int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
	String intern() 返回字符串对象的规范化表示形式。
	int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
	int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
	int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
	int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
	int length() 返回此字符串的长度。
	boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
	boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
	String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
	String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
	String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
	String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
	String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。
	boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
	boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
	CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列。
	String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
	String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
	char[] toCharArray() 将此字符串转换为一个新的字符数组。
	String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
	String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
	String toString() 返回此对象本身（它已经是一个字符串！）。
	String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
	String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
	String trim() 返回字符串的副本，忽略前导空白和尾部空白。
	static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。
	contains(CharSequence chars) 判断是否包含指定的字符系列。
	isEmpty() 判断字符串是否为空。

九、Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

public class Lianxi {
    public static void main(String args[]){
        StringBuilder sb = new StringBuilder(10);
        sb.append("Yoinsdes..");
        System.out.println(sb);
        sb.append("!");
        System.out.println(sb);
        sb.insert(8, "Java");
        System.out.println(sb);
        sb.delete(5,8);
        System.out.println(sb);
    }

}


Yoinsdes..
Yoinsdes..!
YoinsdesJava..!
YoinsJava..!

	方法描述
	public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
	public StringBuffer reverse() 将此字符序列用其反转形式取代。
	public delete(int start, int end) 移除此序列的子字符串中的字符。
	public insert(int offset, int i) 将 `int` 参数的字符串表示形式插入此序列中。
	insert(int offset, String str) 将 `str` 参数的字符串插入此序列中。
	replace(int start, int end, String str) 使用给定 `String` 中的字符替换此序列的子字符串中的字符。

	int capacity() 返回当前容量。
	char charAt(int index) 返回此序列中指定索引处的 `char` 值。
	void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 `dst`。
	int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
	int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
	int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
	int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
	int length() 返回长度（字符数）。
	void setCharAt(int index, char ch) 将给定索引处的字符设置为 `ch`。
	void setLength(int newLength) 设置字符序列的长度。
	CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
	String substring(int start) 返回一个新的 `String`，它包含此字符序列当前所包含的字符子序列。
	String substring(int start, int end) 返回一个新的 `String`，它包含此序列当前所包含的字符子序列。
	String toString() 返回此序列中数据的字符串表示形式。

十、数组

1.数组的创建

dataType[] arrayRefVar;
int [] a;
a = new int[100];



dataType[] arrayRefVar = new dataType[arraySize];
int [] b =new int[100];

2.For-Each 循环

for(type element: array)
{
    System.out.println(element);
}




public class Lianxi {
    public static void main(String args[]){
        int [] b =new int[15];
        for (int i = 0; i < 10; i++) {
            b[i]=i;
        }
        for(int a: b){
            System.out.print(a+" ");
        }
    }

}


0 1 2 3 4 5 6 7 8 9 0 0 0 0 0

3.数组作为函数的返回值

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

4.多维数组

多维数组的动态初始化（以二维数组为例）

type[][] typeName = new type[typeLength1][typeLength2];


int[][] a = new int[2][3];

5.Arrays 类

给数组赋值：通过 fill 方法。

        fill(a,a+n,1)
        第一个参数是起始地址
        第二个参数是我们需要结束的地方，但不会报告a[n]，区间为[a[0],a[n])前闭后开
        第三个参数是我们需要的赋值，这个相对memeset()就灵活很多

Arrays.fill(a[0],a[0]+10*10,c);
	for(int i=0;i<10;i++){
		for(int j=0;j<10;j++){
			System.out.print(a[i][j]);
		}

对数组排序：通过 sort 方法,按升序。

        Arrays.sort(数组, 起始, 末位置);

比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

十一、Java 日期时间

1.定义与初始化

// 使用当前日期和时间来初始化对象。

Date date = new Date();

//初始化时间

Date date2 = new Date(99,12,2);//年，月，日


public class Lianxi {
    public static void main(String args[]){
        Date date1 = new Date();
        System.out.println(date1);

    }

}


Sat Dec 04 18:05:25 CST 2021

2.Date方法

Date 对象创建以后，可以调用下面的方法。

	方法和描述
	boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
	boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
	int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
	boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
	long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
	void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
	String toString( ) 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

public class Lianxi {
    public static void main(String args[]){
        Date date1 = new Date();
        Date date2 = new Date(99,12,2);
        System.out.println(date1.after(date2));
        System.out.println(date1.before(date2));
        System.out.println(date1.compareTo(date2));
        System.out.println(date1.equals(date2));
        System.out.println(date1.getTime());
        date2.setTime(4546464);
        System.out.println(date2);
        System.out.println(date1.toString());

    }

}

true
false
1
false
1638612967054
Thu Jan 01 09:15:46 CST 1970
Sat Dec 04 18:16:07 CST 2021

3.使用 SimpleDateFormat 格式化日期

SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。

SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");

其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。
有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。

import java.text.SimpleDateFormat;
import java.util.Date;
public class Lianxi {
    public static void main(String args[]){
        Date date1 = new Date();
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println(sd.format(date1));
    }

}

2021-12-04 06:27:46

4.Java 休眠(sleep)

sleep()使当前线程进入停滞状态

import java.text.SimpleDateFormat;
import java.util.Date;
public class Lianxi {
    public static void main(String args[]) throws InterruptedException {
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date date1 = new Date();
        System.out.println(sd.format(date1));
        Thread.sleep(1000);
        Date date2 = new Date();
        System.out.println(sd.format(date2));
    }
}


2021-12-04 06:41:35
2021-12-04 06:41:36

5.Calendar类

Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

Calendar类对象字段类型

常量	描述
Calendar.YEAR	年份
Calendar.MONTH	月份
Calendar.DATE	日期
Calendar.DAY_OF_MONTH	日期，和上面的字段意义完全相同
Calendar.HOUR	12小时制的小时
Calendar.HOUR_OF_DAY	24小时制的小时
Calendar.MINUTE	分钟
Calendar.SECOND	秒
Calendar.DAY_OF_WEEK	星期几

定义

Calendar c = Calendar.getInstance();//默认是当前日期

设置数值——Set设置

set(int year,int month,int date)


Calendar c1 = Calendar.getInstance();
c1.set(2009, 6, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12

set(int field,int value)//所改区域，所改数值



Calendar c1 = Calendar.getInstance();
c1.set(Calendar.DATE,10);
c1.set(Calendar.YEAR,2008);

设置数值——Add设置

add(int field,int value)//增加某个区域，并且赋值


Calendar c1 = Calendar.getInstance();
c1.add(Calendar.DATE, 10);

十二、方法

java的地址传递

利用类改变数值

public class Lianxi {
    Swss s = new Swss();//Swss 的对象
    public static void main(String args[]){
        Lianxi l = new Lianxi();
        System.out.println(l.s.a);
        System.out.println(l.s.b);
        l.swap();
        System.out.println(l.s.a);
        System.out.println(l.s.b);
    }
    public void swap(){
        int t;
        t=s.a;
        s.a=s.b;
        s.b=t;
    }
}
class Swss{
    public int a=6;
    public int b=10;
}

可变参数

在方法声明中，在指定参数类型后加一个省略号(...) 。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

事实上传入数据看作一个数组

typeName... Arr

public class Lianxi {
    public static void main(String args[]){
        int a=6;
        int b=10;
        int c= 5;
        System.out.println(swap(a, b));
        System.out.println(swap(a, b, c));
    }
    public static int swap(int...arr){//arr是数组
        int sum=0;
        for(int i=0;i< arr.length;i++){
            sum+=arr[i];
        }
        return sum;
    }
}

十三、Java 流(Stream)、文件(File)和IO

读取控制台输入

System.in 包装在一个 BufferedReader 对象中来创建一个字符流。

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

从控制台读取多字符输入

BufferedReader 对象读取一个字符要使用 read() 方法

int read( ) throws IOException

用 read() 方法从控制台不断读取字符直到用户输入 q

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Read {
    public static void main(String[] args) throws IOException {
        char c;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入字符，按下‘p’键退出。");
        do {
            c = (char) br.read();
            System.out.println(c);
        }while (c!='p');
    }
}

FileInputStream

使用字符串类型的文件名来创建一个输入流对象来读取文件：

InputStream f = new FileInputStream("C:/java/hello");

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

File f = new File("C:/java/hello");
InputStream in = new FileInputStream(f);

import java.io.*;

public class Write {
    public static void main(String[] args) throws IOException {
        FileInputStream fr = new FileInputStream("D:\\lianxi\\java\\lianxiproject\\src\\exercise\\流\\hello.txt");
        
        
        File f = new File("D:\\lianxi\\java\\lianxiproject\\src\\exercise\\流\\hello.txt");
        InputStream de = new FileInputStream(f);
    }
}

FileOutputStream

用字符串类型的文件名来创建一个输出流对象：

OutputStream f = new FileOutputStream("C:/java/hello")

使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：

File f = new File("C:/java/hello");
OutputStream fOut = new FileOutputStream(f);

import java.io.*;

public class OUT {
    public static void main(String[] args) throws IOException {
        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建

        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk

        writer.append("中文输入");
        // 写入到缓冲区

        writer.append("\r\n");
        // 换行

        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入

        writer.close();
        // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉

        fop.close();
        // 关闭输出流,释放系统资源

        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象

        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同

        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流

        fip.close();
        // 关闭输入流,释放系统资源

    }
}

Java File类

通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。

File(File parent, String child);

通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。

File(String pathname)

根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(String parent, String child)

通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。

File(URI uri)

Java FileReader类

在给定从中读取数据的 File 的情况下创建一个新 FileReader。

FileReader(File file)

在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。

FileReader(FileDescriptor fd)

在给定从中读取数据的文件名的情况下创建一个新 FileReader。

FileReader(String fileName)

Java FileWriter类

在给出 File 对象的情况下构造一个 FileWriter 对象。

FileWriter(File file)

在给出 File 对象的情况下构造一个 FileWriter 对象。

 FileWriter(File file, boolean append)

构造与某个文件描述符相关联的 FileWriter 对象。

FileWriter(FileDescriptor fd)

在给出文件名的情况下构造 FileWriter 对象，它具有指示是否挂起写入数据的 boolean 值。

FileWriter(String fileName, boolean append)

import java.io.*;
 
public class FileRead {
    public static void main(String args[]) throws IOException {
        File file = new File("Hello1.txt");
        // 创建文件
        file.createNewFile();
        // creates a FileWriter Object
        FileWriter writer = new FileWriter(file);
        // 向文件写入内容
        writer.write("This\n is\n an\n example\n");
        writer.flush();
        writer.close();
        // 创建 FileReader 对象
        FileReader fr = new FileReader(file);
        char[] a = new char[50];
        fr.read(a); // 从数组中读取内容
        for (char c : a)
            System.out.print(c); // 一个个打印字符
        fr.close();
    }
}


This
is
an
example

十四、Java Scanner 类

next() 与 nextLine() 区别

next():

一定要读取到有效字符后才可以结束输入。
对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

nextLine()：

以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白。

        Scanner sc =new Scanner(System.in);

        String str1 = sc.next();
        String str2 = sc.nextLine();

        System.out.println(str1);
        System.out.println(str2);



           ddw23345 asd wdwd dfewq
ddw23345
 asd wdwd dfewq

十五、Java 异常处理

捕获异常

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

public class demo {
    public static void main(String[] args) {
        try {
            int []str = new int[2];
            System.out.println(str[1]);
            System.out.println(str[4]);

        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
            System.out.println("溢出");
        }finally {
            System.out.println("检查完毕！！");
        }

    }
}


0
java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 2
溢出
检查完毕！！

十六、继承

继承的特性

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object

继承关键字

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

public class Father {
    public void eat(){
        System.out.println("父类的函数");
    }

}
public class Child extends Father{
    public void eat(){
        System.out.println("子类的函数");
    }
    public void eatTest(){
        super.eat();//调用父类函数
        this.eat();//调用自己的函数
    }
}
public class Test {
    public static void main(String[] args) {
        Father f = new Father();
        f.eat();//父类调用
        System.out.println("-----------------------------------");
        Child c = new Child();
        c.eatTest();//子类调用
    }
}



父类的函数
-----------------------------------
父类的函数
子类的函数

十七、Java 重写(Override)与重载(Overload)

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。

public class Father {
    public void eat(){
        System.out.println("父类的函数");
    }

}
public class Child extends Father{
    @Override
    public void eat() {
        System.out.println("fgfj");
    }
}
public class Test {
    public static void main(String[] args) {
        Father f = new Father();
        f.eat();//父类调用
        System.out.println("-----------------------------------");
        Father a = new Child();
        Child c = new Child();
        a.eat();//执行子类的函数
        c.eat();//子类调用
    }
}


父类的函数
-----------------------------------
fgfj
fgfj

方法的重写规则

- 参数列表与被重写方法的参数列表必须完全相同。
- 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类
- 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
- 父类的成员方法只能被它的子类重写。
- 声明为 final 的方法不能被重写。
- 声明为 static 的方法不能被重写，但是能够被再次声明。
- 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
- 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
- 构造方法不能被重写。
- 如果不能继承一个类，则不能重写该类的方法。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
方法能够在同一个类中或者在一个子类中被重载；

十八、多态

多态存在的三个必要条件：

继承
重写
父类引用指向子类对象：

Parent p = new Child();


public class Circle extends Shape{
    @Override
    public void show() {
        System.out.println("circle");
    }
}

public class Sqare extends Shape{
    @Override
    public void show() {
        System.out.println("sqare");
    }
}
public class Shape {
    public void show(){
    }
}
public class Main {
    public static void main(String[] args) {
        Shape a = new Circle();//a是Square 下的对象
        Shape b = new Sqare();//b是Square 下的对象
        a.show();
        b.show();
    }
}




circle
sqare

十九、抽象

1.抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。
抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

2.抽象方法

类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。

Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。
抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。
如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
}

总结：

抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

public abstract class Person {
    private String name;
    private int age;
    private int id;

    public Person(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
    public void eat(){
        System.out.println("person eat");
    }
    public void play(){
        System.out.println("person play");
    }
    public void sleep(){
        System.out.println("person sleep");
    }
    public abstract void a();//抽象方法
}


public class Student extends Person{
    public Student(String name, int age, int id) {
        super(name, age, id);
    }

    @Override
    public void a() {
        System.out.println("抽象方法");
    }
}


public class Main {
    public static void main(String[] args) {
        Student student = new Student("xiaoming", 100, 001);
        student.eat();
        System.out.println(student.getName());
        student.a();
    }
}

二十、集合框架

1.链表（Linked list）

一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

LinkedList 继承了 AbstractSequentialList 类。

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现了 List 接口，可进行列表的相关操作。

LinkedList 实现了 Deque 接口，可作为队列使用。

LinkedList 实现了 Cloneable 接口，可实现克隆。

LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

import java.util.LinkedList;

public class Test1 {
    public static void main(String[] args) {
        LinkedList<String> str = new LinkedList<>();
        str.add("baba");
        str.add("b");
        str.add("ba");
        str.add("bab");
        System.out.println(str);
        System.out.println(str.get(0));
        System.out.println(str.indexOf("ba"));
    }
}


[baba, b, ba, bab]
baba
2

2.ArrayList 类

一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

ArrayList 继承了 AbstractList ，并实现了 List 接口。

import java.util.ArrayList;

public class Test2 {
    public static void main(String[] args) {
        ArrayList<String> str = new ArrayList<>();
        str.add("a");
        str.add("ab");
        str.add("abc");
        str.add("abcd");
        System.out.println(str.get(2));
        str.set(3,"erzi");
        System.out.println(str);
        str.remove("a");
        str.remove(2);
        System.out.println(str);


    }
}


abc
[a, ab, abc, erzi]
[ab, abc]

Java ArrayList 方法(出自菜鸟教程)

Java ArrayList 常用方法列表如下：

方法	描述
add()	将元素插入到指定位置的 arraylist 中
addAll()	添加集合中的所有元素到 arraylist 中
clear()	删除 arraylist 中的所有元素
clone()	复制一份 arraylist
contains()	判断元素是否在 arraylist
get()	通过索引值获取 arraylist 中的元素
indexOf()	返回 arraylist 中元素的索引值
removeAll()	删除存在于指定集合中的 arraylist 里的所有元素
remove()	删除 arraylist 里的单个元素
size()	返回 arraylist 里元素数量
isEmpty()	判断 arraylist 是否为空
subList()	截取部分 arraylist 的元素
set()	替换 arraylist 中指定索引的元素
sort()	对 arraylist 元素进行排序
toArray()	将 arraylist 转换为数组
toString()	将 arraylist 转换为字符串
ensureCapacity()	设置指定容量大小的 arraylist
lastIndexOf()	返回指定元素在 arraylist 中最后一次出现的位置
retainAll()	保留 arraylist 中在指定集合中也存在的那些元素
containsAll()	查看 arraylist 是否包含指定集合中的所有元素
trimToSize()	将 arraylist 中的容量调整为数组中的元素个数
removeRange()	删除 arraylist 中指定索引之间存在的元素
replaceAll()	将给定的操作内容替换掉数组中每一个元素
removeIf()	删除所有满足特定条件的 arraylist 元素
forEach()	遍历 arraylist 中每一个元素并执行特定操作

如果我们要存储其他类型，而 <E> 只能为引用数据类型，这时我们就需要使用到基本类型的包装类。

基本类型引用类型
boolean Boolean
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character

基本类型	引用类型
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character

3.Java HashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

HashSet 允许有 null 值。

HashSet 是无序的，即不会记录插入的顺序。

二十一、泛型

1.泛型方法

所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 <E>）。
每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）。

public class Test1
{
    // 泛型方法 printArray
    public static < E > void printArray( E[] inputArray )
    {
        // 输出数组元素
        for ( E element : inputArray ){
            System.out.printf( "%s ", element );
        }
        System.out.println();
    }

    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组

        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组

        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    }
}





整型数组元素为:
1 2 3 4 5 

双精度型数组元素为:
1.1 2.2 3.3 4.4 

字符型数组元素为:
H E L L O

2.泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。
和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("ssdss"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}



整型值为 :10

字符串为 :ssdss

Yoin.

关注

1
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java基础知识

一、对象与类1.类对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。类：类是一个模板，它描述一类对象的行为和状态。public class Dog { String breed; int size; String colour; int age; void eat() { } void run() { } void sleep(){
复制链接

扫一扫