Java由浅入深，基础到进阶(持续更新中)

ideal中的快捷键

1.alt+Insert选中成员变量然后可以自动创建带参或者无参构造（选中类名）。
2.当子类继承父类创建构造方法时，直接选择参数点击确定后，无参构造方法也会被创建。
3.子类重写父类方法时，输入需要重写的方法然后按Enter键即可。
4.API中找方法，首先ctrl+B进入类；然后alt+7打开方法列表，并将列表放在右侧。

1.关于构造方法

作用：明确方法的属性，例如姓名，年龄等

schoolDemo2：
Demo:

package schoolDemo2;

/*
    测试类
*/
public class Demo {
   
    public static void main(String[] args) {
   
        //无参构造可以运行不报错是因为如果自己不写无参构造的话，系统自动生成一个无参构造
        //创建老师类对象进行测试
        var t1 = new Teacher();
        t1.setName("林青霞");
        t1.setAge(16);
        System.out.println(t1.getName() + "," + t1.getAge());
        t1.teach();
        System.out.println("-------------------");
//直接创建带参的对象报错是因为，student中没有创建带参构造，系统也不会自动生成带参构造，所以必须自己创建带参的构造.如果自己创建了带参构造，那么系统将不会自动创建无参构造，所以，当创建带参构造的时候，必须一块创建一个无参构造。
        var s1 = new Student("风清扬", 16);
        System.out.println(s1.getName() + "," + s1.getAge());
        s1.Study();

    }
}

package schoolDemo2;

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

    public Person() {
   

    }

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

    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;
    }
}

package schoolDemo2;

public class Student extends Person {
   
    public Student() {
   
    }

    public Student(String name, int age) {
   
        super(name, age);
    }

    public void Study() {
   
        System.out.println("好好学习天天向上");
    }
}

package schoolDemo2;

public class Teacher extends Person{
   
    public void teach(){
   
        System.out.println("用爱成就每一位学员");
    }
}

研究

class Array {
   

    /**
     * Constructor.  Class Array is not instantiable.
     */
    private Array() {
   }

例如Array这个类，如果没有创建构造方法，系统将会自动给出一个无参构造方法，然后用户就可以利用这个无参构造方法来创建对象（用new创建对象），为了防止被创建对象，作者给出了一个private修饰的无参构造方法，这样就不能直接访问和创建对象。但是Array类里面的方法都用static修饰，想要使用Array这个类的方法，需要类名调用方法。这就是Array这个类的设计思路。

2.成员变量和局部变量

var的用法:

var可以用于局部变量中，但是不能用在成员变量中。在不影响程序可读性的情况下推荐用var.

3.包（package）其实就是文件夹

作用：对类进行分类管理

用法：import导包，不然就得像文件夹地址一样输入

4.权限修饰符

修饰符	同一个类中	同一个包中子类无关类	不同包的子类	不同包的无关类
private	ok	false	false	false
默认(void)	ok	ok	false	false
protected	ok	ok	ok	false
public	ok	ok	ok	ok

final

final修饰基本类型：

final int age = 20;
age就变成了一个常量，不能再被赋值.即数据值不能再改变。

final修饰引用类型变量：

final Student s = new Student();
s.age = 100;
输出结果s.age = 100.
其中s的地址值不会再改变，地址值指向的内容，例如age可以变化，但是地址不会改变。
引用类型的地址值不能再改变。

static:

被类的所有对象共享：这也是我们判断是否使用静态关键字的条件。
被static修饰的变量一旦被赋值，则会被所有对象共享，通过随便一个对象赋值一次就好了。
可以通过类名调用（推荐）

static访问特点：静态的成员方法，只能访问静态的成员。非静态的成员方法可以访问非静态和静态的成员。

5.多态

概念：由父类引用指向子类对象。

public class Cat extends Animal{
   
	Animal ani = new Cat();
}

特点：

1.多态的形式访问变量，编译和运行都要看左边，Aniaml有的变量才能运行，并且运行结果是Animal的变量值。
2.多态的形式访问成员方法，编译看左边，运行看右边，Aniaml有的成员方法才能运行，并且运行结果是Cat的成员方法(如果子类重写了父类的方法，则多态输出的方法是子类重写之后的数据)。
3.为什么成员变量和成员方法的访问不一样呢？因为成员方法有重写，而成员变量没有。
4.其实多态里面只需要声明一个类型是父类的变量即可，例如：

Animal a;
a = new Cat("XiaoMiao",1);
....
a = new Dog();
a.eat();

6.抽象

概念：如果一个方法没有方法体，则这个方法是个抽象方法，用abstract定义，并且抽象方法应该在抽象类里面。

例如：public abstract void eat();

意义和用法：用abstract修饰

1.比如说，有Animal类，Cat类，Dog类。Cat类和Dog类都继承Animal类，Animal类中有一个eat()方法，但是猫狗吃的东西是不一样的，所以这个eat()方法应该是空的，也就是抽象方法。
2.抽象类不是具体的，所以不能直接实例化对象。但是可以参照多态的形式实例化对象。例如：Animal a = new Cat();因为Cat类中的方法重写了Animal类的抽象方法。所以，子类必须重写父类中的所有抽象方法。如果不重写父类抽象类的抽象方法，那么子类也必须是一个抽象类，但是如果想要实例化子类对象，也必须重写子类中的抽象方法。
3.抽象类中不一定有抽象方法，但是有抽象方法一定有抽象类。

package chouXiang_11;

public abstract class Animal {
   
    public abstract void eat();
    public void sleep(){
   
        System.out.println("睡觉");
    }
}

package chouXiang_11;

public class AnimalDemo {
   
    public static void main(String[] args) {
   
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

package chouXiang_11;

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

package chouXiang_11;

public abstract class Dog extends Animal{
   
}

抽象类的成员特点

1.父类的抽象方法存在的意义在于：限定子类必须重写某种方法（因为父类的抽象方法是一个没有方法体的方法）。

7.java接口

概念

接口就是一种公共的规范标准，只要符合规范，大家都可以通用。java中的接口更多的体现在对行为的抽象。

接口的特点

1.关键字interface:
public interface 接口名{}
2.类实现接口用implements表示：
public class 类名 implements 接口名 {}
3.接口不能直接实例化：
想要实例化的话，参照抽象类多态的方式，这叫接口多态。

接口的成员特点

1.成员变量：
只能是常量
默认修饰符：public static final
2.构造方法：
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在
一个类如果没有父类，默认继承自Object类
3.成员方法：
只能是抽象方法
默认修饰符：public abstract

8.接口多态和抽象多态

接口多态只能调用接口的方法，抽象多态只能调用抽象的方法。但是这需要创建两个对象，所以实际写代码的时候不会创建两个对象，而是创建一个子类对象，因为子类对象重写了所有的方法，是最全的，用子类对象来调用所有的方法。

9.抽象类和接口的区别

成员区别：
抽象类：变量，常量，有构造方法，有抽象方法，也有非抽象方法。
借口：常量，抽象方法
关系区别：
类与类：继承，单继承
类与接口：实现，可以单实现，也可以多实现
接口与接口：继承，单继承，多继承
设计理念区别：
抽象类：对类抽象，包括属性，行为
借口：对行为抽象，主要是行为
抽象类是对事物的抽象，接口是对行为的抽象。

10.内部类和外部类

访问特点：内部类可以访问外部类的成员（成员变量和成员方法），包括私有。外部类要访问内部类的成员，必须先创建对象。

成员内部类

外界如何访问成员内部类(public修饰的，不过意义不大，因为既然当做内部类，就不想被访问到，所以需要用private修饰)？
格式：外部类名.内部类名 对象名 = 外部对象.内部对象;
范例：Outer.Inner oi = new Outer().new Inner();

局部内部类

11.匿名内部类

前提：
存在一个类或者接口，这里的类可以是具体的，也可以是抽象的。
格式：
new 类名或者接口名(){
重写方法;
}
本质是什么呢？
是一个继承了该类或者实现了该接口的子类匿名对象
范例：

public class Outer{
   
	public void method(){
   
		Inner i = new Inner(){
   
			@override
			public void show(){
   
				System.out.println("匿名内部类");
			}
		}.show();   //因为这是个对象，而对象可以调方法
	}
}

意义

当有很多类似的事物，比如说，猫可以跳高了，狗可以跳高了，猪可以跳高了等，这些类只用一次，所以没必要创建这么多类似的类，就是用匿名内部类来做。

12.自动装箱和自动拆箱

装箱：基本数据类型转化为对应的包装类型，例如
int - Integer
拆箱：包装类型转化为相应的基本类型，例如
Integer - int
自动装箱：Integer i = 100;
其中底层自动完成步骤为：Integer i = Integer.valueOf(100);

13.空指针异常

null本身就是空，空调用方法肯定是空指针异常，所以调用方法时，首先需要判断是不是空指针。
例如：

Integer iii = null;
iii += 300;//NullPointerException

改为：

Integer iii = null;
	if(iii