# Java基础知识

1.两个对象在内存图

2.private

一旦使用private进行修饰，那么在本类中任然可以随意访问，但是，超出了本类范围之外就不能直接访问了。


但是可以间接访问，就是定义一对Getter/Setter方法。

对于基本类型当中的Boolean值，Getter方法一定要写成isXxx的形式，Setter方法不变。

3.this

• ​ 当方法的局部变量和成员变量重名的时候，根据’就近原则‘，优先使用局部变量。

• ​ 如果需要访问本类当中的成员变量，需要使用格式：

• ​ this.成员变量名

• ​ “通过谁调用的方法，谁就是this”
  

4.构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。格式:

​ public 类名称(参数类型 参数名称){

​ 方法体

​ }

注意事项：

1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样

2. 构造方法不要写返回值类型,连void都不写

3. 构造方法不能return—个具体的返回值

4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。

public  Student() { }

5. —旦编写了至少一个构造方法，那么编译器将不再赠送。

6. 构造方法也是可以重载的

重载：方法名称相同，参数列表不同

5.标准的类

一个标准的类通常要拥有下面四个组成部分:

1. 所有的成员变量都要使用private关键字修饰

2. 为每一个成员变量编写一对儿Getter/Setter方法

3. 编写一个无参数的构造方法

4. 编写一个全参数的构造方法这样标准的类也叫做Java Bean

6.Scanner

1. 导包

   import java.util.Scanner;
   

2. 创建

   //备注：System.in代表从键盘进行输入
   Scanner sc = new Scanner(System.in);
   

3. 使用

   //获取键盘输入的一个int数字:int num = sc.nextInt( );
   
   //获取键盘输入的一个字符串:String str = sc.next( );
   

7.匿名对象

• ​ 匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。格式：

• ​ new 类名称();

• ​ 注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。

• ​ 使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。

8.Random

Random类用来生成随机数字。使用起来也是三个步骤;

1. 导包

   import java.util.Random;
   

2. 创建

   Random r = new Random(); //小括号当中留空即可
   

3. 使用

   获取一个随机的int数字（范围是int所有范围，有正负两种）:

    int num = r.nextInt()
   

   获取一个随机的int数字（参数代表了范围，左闭右开区间):

    int num = r.nextInt(3)
   

   实际上代表的含义是:[0,3)，也就是0~2

9.ArrayList集合

1.概念

• ​ 数组的长度不可以发生改变。

• ​ 但是ArrayList集合的长度是可以随意变化的。

• ​ 对于ArrayList来说，有一个尖括号代表泛型。

• ​ 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。

• ​ 注意：泛型只能是引用类型，不能是基本类型。

//创建了一个ArrayList集合，集合的名称是List，里面装的全都是string字符串类型的数据
//备注:从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
ArrayList<String> list = new ArrayList<>();

​ 注意事项:

​ 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容是空，得到的是空的中括号：[ ]

2.常用的方法

public boolean add(E e);//向集合当中添加元素，参数的类型和泛型一致。返回值代表添加成功
//备注:对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
//但是对于其他集合(今后学习)来说，add添加动作不一定成功。

public E get(int index);//从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

public E remove(int index);//从集合当中删除元素，参数是索引编号，返回值就是被珊除掉的元素。

public int size();//获取集合的尺寸长度，返回值是集合中包含的元素个数。

泛型只能是引用类型，不能是基本类型，如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类

基本类型 包装类（引用类型，包装类都位于java.Lang包下)

byte Byte

short Short

int Integer 【特殊】

long Long

float Float

double Double

char Charactor 【特殊】

boolean Boolean

10.字符串

• ​ java.Lang.String类代表字符串。

• ​ API当中说：Java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。

• ​ 其实就是说：程序当中所有的双引号字符串，都是string类的对象。(就算没有new，也照样是。)

1.字符串的特点：

1. 字符串的内容永不可变。【重点】
2. 正是因为字符串不可改变，所以字符串是可以共享使用的。
3. 字符串效果上相当于是char[ ]字符数组，但是底层原理是byte[ ]字节数组。

2.创建字符串的常见3+1种方式。

三种构造方法：

1. public String():创建一个空白字符串，不含有任何内容。
2. public String(char[ ] array):根据字符数组的内容，来创建对应的字符串。
3. public String(byte[ ] array):根据字节数组的内容，来创建对应的字符串。

—种直接创建：

​ String str = “HeLLo”;

3.字符串常量池

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。

​ 对于基本类型来说，==是进行数值的比较。

​ 对于引用类型来说，==是进行地址值的比较。

4.字符串常量池内存图

5.字符串常用的方法

1.比较值的方法

==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法;
public boolean equals(0bject obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回false。
public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。

​ 注意事项：

1. 任何对象都能用object进行接收。

2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。

3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。

   推荐：“abc”.equals(str) 不推荐：str.equals( “abc”)

2.与获取的方法

public int Length()：获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)：获取指定索引位置的单个字符。(索引从e开始。)
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-z值。

3.与截取的方法

public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin，int end)：截取从begin开始，一直到end结束，中间的字符串。
备注：[ begin , end)，包含左边，不包含右边。

4.与转换有关的方法

public char[ ] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldstring,CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：CharSequence意思就是说可以接受字符串类型。

5.与分隔有关的方法

public String[ ] split(String regex):按照参数的规则，将字符串切分成为若干部分。
注意事项：
split方法的参数其实是一个“正则表达式”，今后学习。
今天要注意:如果按照英文句点“.”进行切分，必须写"\\." (两个反斜杠)

11.静态static关键字

1.static修饰成员变量

​ 如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

2.static修饰成员方法

• 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
• 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
• 如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
• 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
• 静态变量：类名称.静态变量
• 静态方法：类名称.静态方法()

注意事项：

1. 静态不能直接访问非静态。

​ 原因：因为在内存当中是先有的静态内容，后有的非静态内容。

​ “先人不知道后人，但是后人知道先人。”

2. 静态方法当中不能用this。

​ 原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。静态方法调用的是类，不是对象。

3.static关键字的内存图

4.静态代码块

​ 静态代码块的格式是：

public class类名称{
    static{
        //静态代码块的内容
    }
}

特点:当第一次用到本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：

​ 用来一次性地对静态成员变量进行赋值。

12.数组工具类Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

//public static String toString(数组):将参数数组变成字符串（按照默认格式:[元素1，元素2，元素3...])
public static void main(String[] args){
    int[] intArrays = {10, 20, 30};
    //将int[]数组按照默认格式变成字符串
    String intStr = Arrays.toString(intArrays);
    System.out.println(intStr);//[10, 20, 30]
}

//public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序
/*
备注:
1. 如果是数值,sort默认按照升序从小到大
2. 如果是字符串， sort默认按照字母升序
3．如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。(今后学习)
*/
public static void main(String[] args) {
    int[] array1 = {2, 1, 3, 10, 6};
    Arrays.sort(array1);
    System.out.println(Arrays.toString(array1));//[1, 2, 3, 6, 10]
}

13.数学工具类Math

/*
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

public static double abs (double num):获取绝对值。有多种重载。
public static double ceil ( double num):向上取整。
public static double floor( double num):向下取整。
public static long round ( double num):四舍五入。

Math.PI 代表近似圆周率
*/
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.15));//3.15
        System.out.println(Math.abs(0));//0
        System.out.println(Math.abs(-2.5));//2.5

        //向上取整
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.ceil(3.1));//4.0
        System.out.println(Math.ceil(3.0));//3.0

        //向下取整。
        System.out.println(Math.floor(3.9));//3.0
        System.out.println(Math.floor(3.9));//3.0
        System.out.println(Math.floor(3.0));//3.0
        
        //四舍五入。
        System.out.println(Math.round(4.5));//5
        System.out.println(Math.round(4.3));//4
        System.out.println(Math.round(4.0));//4
    }

14.继承

1.重写和重载

• 重写(Override)：方法的名称一样，参数列表也—样。
• 重载(Overload)：方法的名称一样，参数列表不一样。

2.supper关键字

/*
super关键字的用法有三种:
1．在子类的成员方法中，访间父类的成员变量。
2．在子类的成员方法中，访问父类的戒员方法。
3．在子类的构造方法中，访问父类的构造方法。
*/

//子类
public class Zi extends Fu{
    int num = 20;
    
    public Zi() {
    	super();
    }
    
    public void methodZi(){
        System.out.println(super.num); //父类中的num
    }
    
    public void method(){
        super.method();//访问父类中的method
        System.out.println("子类方法");
    }
}

//父类
public class Fu(){
    int num = 10;
    public void method(){
        System.out.println("父类方法");
    }
}

3.this关键字

/*
super关键字用来访问父类内容，而this关键字用来访间本类内容。用法也有三种:

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3．在本类的构造方法中,访问本类的另一个构造方法。
在第三种用法当中要注意:
A. this( ...)调用也必须是构造方法的第一个语句，唯—一个。
B. super和this两种构造调用,不能同时使用。
*/

4.继承的三个特点

1. Java语言是单继承的。一个类的直接父类只能有唯一一个。
2. Java语言可以多级继承。我有一个父亲，我父亲还有一个父亲，也就是爷爷。
3. 一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类。可以有很多个兄弟姐妹，生二胎。

15.抽象

1.抽象方法和抽象类

/*
抽象方法:就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类:抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
*/
//抽象类
public abstract class Animal(){
    //这是抽象方法
    //public abstract 返回值类型 抽象方法名();
    public abstract void eat();
    
    //这是一个普通方法
    //public void normalMethod(){
    //}
}

public class Cat extends Animal(){
    @Override
    public  void eat(){
        System.out.println("猫吃鱼");
    }
}

public class Demo(){
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.eat();
    }
}

2.如何使用抽象类和抽象方法

1. 不能直接创建new抽象类对象。

2. 必须用一个子类来继承抽象父类。

3. 子类必须覆盖重写抽象父类当中所有的抽象方法。

   覆盖重写(实现):子类去掉抽象方法的abstract关键字，然后补上方法体大括号。

4. 创建子类对象进行使用。

3.注意事项

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

   理解:假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

   理解:子类的构造方法中，有默认的super()，需要访问父类构造方法。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

   理解:未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

   理解:假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

16.接口

1.接口的概念

接口就是多个类的公共规范。
接口是—种引用数据类型，最重要的内容就是其中的:抽象方法。如何定义一个接口的格式:
public interface接口名称{
//接口内容
}
备注:换成了关键字interface之后，编译生成的字节码文件仍然是: .java --> .class。
知果是Java 7，那么接口中可以包含的内容有:
1．常量
2．抽象方法
如果是Java 8，还可以额外包含有:
3．默认方法
4．静态方法
如果是Java 9，还可以额外包含有:
5．私有方法

注意事项：
1．接口当中的抽象方法，修饰符必须是两个固定的关键字: public abstract
2．这两个关键字修饰符，可以选择性地省略。(今天刚学，所以不推荐。)

17.多态

1.概念

extends继承或者implements实现，是多态性的前提。

小明是一个对象。
这个对象既有学生形态，也有人类形态。一个对象拥有多种形态，这就是:
对象的多态性

2.多态的格式和使用

代码当中体现多态性，其实就是一句话:父类引用指向子类对象。格式:
交类名称 对象名= new 子类名称();
或者:
接口名称 对象名= new 实现类名称();

public static void main(String[] args){
	//使用多态的写法
	//左侧父类的引用，指向了右侧子类的对象
	Fu obj = new Zi();
	
	obj.method();//输出“子类方法”
	obj.methodFu();//输出“父类特有方法”
}

public class Fu{
	public void method(){
		System.out.println("父类方法");
	}
	public void method2(){
		System.out.println("父类特有方法");
	}
}

public class Zi extends Fu{
	public void method(){
		System.out.println("子类方法");
	}
}

3.多态中的成员变量使用

访间成员变量的两种方式:
1．直接通过对象名称访问成员变量:看等号左边是谁，优先用谁，没有则向上找。
2．间接通过成员方法访问成员变量:看该方法属于谁，优先用谁，没有则向上找。
public static void main(String[] args) {
	//使用多态的写法,父类引用指向子类对象
    Fu obj = new Zi();
    System.out.println(obj.num); //父:14
      //System.out.printLn(obj.age); //错误写法!
    system.out.println( "=============");
    //子类没有覆盖重写，就是父:10
    //子类如果覆盖重写，就是子:20
    obj.showNum(); 
}

public class Fu {
    int num = 10;
    
    public void showNum(){
        System.out.println(num);
    }
}

public class zi extends Fu {
    int num = 20;
    int age = 16;

    @Override
    public void showNum(){
        System.out.println(num);
    }
}

4.多态中的成员方法的使用

在多态的代码当中，成员方法的访问规则是:
	看new的是谁,就优先用谁，没有则向上找。
        
口诀:编译看左边,运行看右边。
    
对比一下：
    成员变量：编译看左边，运行还看左边。
    成员方法：编译看左边，运行看右边。
public class Demo02MultiMethod {
    public static void main(String[]args) {
        Fu obj = new Zi();//多态
        obj.method(); //父子都有，优先用子
        obj.methodFu();//子类没有，父类有,向上找到父类
        
        //编译看左边,左边是Fu，Fu当中没有methodzi方法，所以编译报错。
        obj.methodZi();//错误写法!
}

5.多态的好处

6.对象的向上转型

7.instanceof

18.final关键字

1.概念

finaL关键字代表最终、不可改变的。

常见四种用法:
1．可以用来修饰一个类
2．可以用来修饰一个方法
3．还可以用来修饰一个局部变量
4.还可以用来修饰一个成员变量

2.用法

1.当final关键字用来修饰一个类的时候。
格式:
public final class类名称{
	//...
}
含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写（因为没有儿子。）
    
2.当final关键字用来修饰一个方法的时候。
格式：
修饰符 final 返回值类型 方法名称(参数列表){
	//方法体
}
含义：这个方法就是最终方法，也就不能被覆盖重写。
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

3.当final关键字来修饰局部变量。
格式：
    final 数据类型 变量名;
含义：一次赋值，终生不变。
注意：1.对于基本类型来说,不可变说的是变量当中的数据不可改变
2.对子引用类型来说,不可变说的是变量当中的地址值不可改变，--值可以改变--
    
4. 当final关键字用来修饰成员变量

含义：1.这个变量照样不可变，由于成员变量具有默认值，所以用了final之后必须手动赋值。
2.对呀final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3.必须保证类当中所以重载的构造方法，都最终会对final的成员变量进行赋值。
    private final String name = "方浴荷";

19.权限修饰符

java中有四种权限修饰符
​		  	              public 	> 	protected 	>	 (default)  >  	private
同一个类	           yes			  yes				   yes				yes
同一个包		       yes			  yes			       yes				no
不同包子类	       yes		      yes				   no				    no
不同包非子类	   yes			  yes				   no				    no

注意事项：(default)并不是关键字"default",而是根本不写