一、main方法介绍

main()：作为程序的入口，是一个普通的静态public方法，虚拟机中执行会去找main()方法，若不存在就会报错，存在即执行。

main方法能与控制台进行交互。

public class Main{
    public static void main(String[] args){
  }
}

其中的args参数我们也可以进行赋值并输出：

①命令行中赋值并输出

首先编译成字节码文件，接着输入java Main "参数1" 1 2 3 后面空格分隔的参数值会赋予到args中，就可以对其进行操作了！！

②IDEA中设置参数

左上角选择你当前运行的java源代码名称—Edit Configuration

在Program argumnets中设置参数即可

二、static关键字

static：共享的，可以修饰属性、方法、代码块、内部类(无构造器)。

修饰属性：此属性就是类中的静态属性，创建多个对象都有一份共享的属性，一个对象修改的话，其他对象拥有的属性也会更改。

静态变量会随着类的加载而加载，放置在缓存区(方法区的静态域)，可以通过类.静态变量直接调用，而不用先创建实例再获取。

类的加载早于对象的加载，加载时间发生在如实例化对象、类名调用静态变量的几个情况下。由于类的加载只有一次，静态变量在内存中只会存在一份。

修饰方法：也就是静态方法，随着类的加载而加载，通过类.静态方法调用。

一般常量也使用static修饰。

注意点：静态方法中，不能使用this,super关键字，并且静态方法中不能调用非静态的属性及方法。(因为静态方法是随着类加载而加载，实例化对象则是在运行阶段)。

相关设计模式：单例模式

三、类成员—代码块

类的成员：方法、属性、构造器、内部类、代码块

代码块：也称为Block、初始化块，分别非静态代码块与静态代码块。

语法：

class Person{
    //非静态代码块
    {
  }
    //静态代码块
    static{
    }
}

非静态代码块：可在创建属性时，对属性进行初始化

创建实例时执行，每创建一次就会执行一次。

若是有多个代码块，按照顺序执行。

可包裹静态、非静态的属性及方法。

静态代码块：为静态属性赋值

随着类的加载而执行，只执行一次

若是有多个静态代码块，根据顺序执行(可合在一个静态代码块中)

只能包裹静态属性与方法

使用场景：连接数据库时，加载properties配置文件。

四、final关键字

final：表示常量，最终的意思

final可修饰结构：类、方法、类变量、局部变量

修饰类：此类不能被其他类所继承。

修饰方法：此方法不能被重写。

修饰变量：此变量为常量，可初始化位置有直接初始化、代码块中初始化、构造器中初始化(只能有一处)。

修饰局部变量

形参：表示常量，在方法中不可对其重新赋值(调用方法时会传参)。

方法中参数：表示常量，不可二次赋值。

初始化举例：下面演示的是不同变量，同一个变量赋过值后无法再重新赋值

class Person{
    public final double MONEY = 20; //1.直接赋值
    public final int NAME;  
    public final String MAJOR;
    public Person(){
        NAME = 10;  //2.在构造器中赋值
    }
    {
        MAJOR = "数学";   //3.在代码块中赋值
    }
}

final使用于方法实例：Object的getClass方法public final native Class<?> getClass();

final使用于类实例：常用类String，public final class String

final使用于变量：String类中的参数private final char value[];

五、abstract关键字

介绍abstract

abstract：可修饰类与方法

修饰类：抽象类，一般来说在开发中会提供抽象类子类，让子类进行实现

无法进行实例化

一定有构造器，方便子类对象实例化时候调用

修饰方法：抽象方法

有抽象方法的必定是抽象类

抽象方法只有方法的声明，没有方法体，例如public abstract void walk();

若子类继承了抽象类，必须重写父类所有抽象方法，否则该子类依旧是抽象类

注意点：①abstract不能修饰属性，构造器等结构。②不能修饰private属性，静态方法，final方法

抽象类

抽象类：主要是用来模型化那些父类无法确定全部实现，而由其子类提供具体实现对象的类。

下面就是一个简单的子类继承抽象类实现抽象方法：目的是要是实现抽象类调用其walk方法

abstract class Person{
    public abstract void walk();
}
class Student extends Person{
    @Override
    public void walk() {
        System.out.println("student走路中.....");
    }
}
public class Main {
    public static void main(String[] args){
        Person student = new Student();
        Person.walk();//student走路中.....
    }
}

匿名抽象类

匿名抽象类：对于抽象类我们是无法直接实例化的，但我们可以通过匿名抽象类的方式来进行实例化，需要注意的是这个实例化对象并非是该抽象类，可以看成其匿名子类，实现抽象方法即可使用。

好处：当我们需要使用某个抽象类中的方法时，一般来说要重新定义一个类来继承抽象类并实现方法，之后将该子类实例化使用实现方法，这里可以直接创建一个匿名子类对象，直接重写方法用。

使用的例子还是上面抽象类里的例子：

abstract class Person{
    public abstract void walk();
}
public class Main {
    public static void main(String[] args){
        //多态：创建匿名抽象类并实例化
        Person person = new Person() {
            @Override
            public void walk() {
                System.out.println("student走路中.....");
            }
        };
        person.walk();//student走路中.....
    }
}

这里使用多态来进行方法调用。

应用场景

需求描述及不合理方案

描述：上面几个动物原本是根据不同的科类划分继承的，现在需要给几个动物如cat、dog这几个动物家养的几个小动能，如何设计最合理？

这里有几个不太合理方案：当做示例

方案一：直接将宠物方法加在Animal类中。

优点：其下所有动物类都可以马上继承其方法，其他新增加的动物也会取得同样行为。

缺点：让原本不是宠物的动物赋予了其方法，很不合理！

方案二：与方案一相同，加Animal类中，不过这里添加的是抽象方法。

优点：其他所有动物类都会重写该方法，定义合理的动作。

缺点：注意其他动物例如老虎狮子，根本完全没必要有并且重写其方法。

方案三：直接把放方法写入到指定的动物身上。

优点：避免其他动物有其宠物的行为。

缺点：对于相同的行为方法，不一样的家宠动物会出现例如doFriendly()、beFriendly()方法，调用时可能会出现不同方法调用。

理清需求以及合理方案

需求描述总结：

一种可以让宠物行为只应用到宠物身上方法

确保所有的宠物的类都有相同的方法定义的方法。

可以应用到多态

合理方案：在cat、dog之上创建一个抽象类名为Pet，并且创建带有宠物的方法，这样指定动物就能够继承其方法，并且还能够使用多态，通过Pet类来进行声明接收。

相关关系见下图，真的秒呀：