面向对象中的关键字

class

public

private

static

final

extends

implements

abstract

this

super

权限修饰符

作用：限定类，属性，方法，构造方法使用范围

包：package,管理JAVA代码的一个工具，在不同的包中，可以定义相同的JAVA文件

实际上，包就是硬盘上的文件夹

1）包名应该怎么定义

反域名命名法：百度的域名：www.baidu.com

map.baidu.com->com.baidu.map.功能

公司类型.公司名.项目名.功能模块名.子功能

2）如何访问别的包中的类？

（1）引入 import 包名.类名

（2）使用类的全名访问 包名.类名

（3）定义类时，指明这个所在的包

public：公共的，任何地方都可以访问

private：私有的，只能在类的内部访问

protected：保护的，可以在同包，以及包外的子类中访问

(default,啥也不写)：默认的，同包可以访问

final

1）修饰常量

常量不能被改变的量

2）修饰方法

最终方法，不能被子类重写

3）修饰类

最终类，不能产生子类

static

静态的

1）修饰属性

当使用static修饰属性时，属性就变成静态属性

静态属性直属于类的，不需要依赖对象

静态属性会在JVM加载类信息时创建，放到静态池中

使用：

可以使用  类名.静态属性

也可以使用 对象.静态属性（不推荐使用这种形式）

没有使用static修饰的属性，称为对象属性/实例属性

2）修饰方法

当使用static修饰方法时，方法就变成静态方法

静态方法直属于类的，不需要依赖对象

使用：

可以使用  类名.静态属性()

也可以使用 对象.静态属性()（不推荐使用这种形式）

静态方法中只能直接使用当前类的静态属性

静态方法中只能直接调用当前类的静态方法

如果非要调用非静态属性和非静态方法，请先创建对象

public class Math {
    //非静态的属性
    String name;
    //静态的属性
    static double PI = 3.14;
    //定义一个方法
    public int max(int a , int b){

        System.out.println(name);//调用非静态属性
        System.out.println(PI);//调用静态属性
        add(20,30);//调用静态方法
        
        return (a>b)?a:b;
    }
    //定义一个静态方法
    public static int add(int a , int b){
        //System.out.println(name);//静态方法不能直接调用非静态属性
        System.out.println(PI);//静态方法可以调用静态属性
        //System.out.println(max(1,2));//静态方法不能直接调用非静态方法
        return a+b;
    }
}

3）修饰类

public class Demo02 {
    public static void main(String[] args) {
        Test test = new Test();
        
    }
    //内部类：定义在类的内部的类就叫做内部类
    static class Test{
        
    }
}

statica在修饰类的时候，只针对内部类

匿名内部类：（线程）

this和super

this:

1）用在类的构造方法或者方法中

在构造方法中使用this，代表的是当前被创建出来的对象

在普通方法中使用this，代表的是调用当前方法的对象

2）在构造方法中使用this();调用当前类的其他构造方法

public class Person {
    private String name;

    public Person(){

    }
    public Person(int num){
        System.out.println(num);
    }
    //构造方法
    public Person(String name) {
        /**
         * 在构造方法中如果下面的这种情况
         * 调用当前类的其他的构造方法
         * 
         * 必须写在构造方法的第一行
         */
        this(100);
        //在构造方法中使用this，代表当前被创建的对象
        this.name = name;
    }
    //普通方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        //在普通方法中使用this，代表调用当前方法的对象
        this.name = name;
    }
}

在静态方法中能否使用this ?不能

为什么？因为静态方法不依赖与对象

super

1）构造方法中使用super();调用父类的构造方法

public class Person {
    private String name;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //打印
    public void print() {
        System.out.println(this.name);
    }
}

public class Employee extends Person{
    private String num;
    public  Employee(){
        super();//调用父类的构造方法
    }
    public Employee(String name,String num) {
        super(name);
        this.num = num;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

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

2）用在重写方法时

public class Employee extends Person{
    private String num;
    public  Employee(){
        super();//调用父类的构造方法
    }
    public Employee(String name,String num) {
        super(name);
        this.num = num;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    @Override
    public void print() {
        //由于当前方法时重写的父类方法，因此父类方法就覆盖掉了
        //有时候需要调用一个父类中被重写前方法
        super.print();//这里的super代表的是父类，所以调用的就是父类的print();方法
        System.out.println(this.num);
    }
}

关于方法的重写

public class Person {
    private String name;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //打印
    public void print() {
        System.out.println(this.name);
    }
    //测试
    protected Person test(){
        return new Person();
    }
    protected long test1(){
        return 0;
    }
}

public class Employee extends Person{
    private String num;
    public  Employee(){
        super();//调用父类的构造方法
    }
    public Employee(String name,String num) {
        super(name);
        this.num = num;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    @Override
    public void print() {
        //由于当前方法时重写的父类方法，因此父类方法就覆盖掉了
        //有时候需要调用一个父类中被重写前方法
        super.print();//这里的super代表的是父类，所以调用的就是父类的print();方法
        System.out.println(this.num);
    }

    //重载了父类的test()方法
    //子类中的方法名与父类相同，但是参数列表不同
    //子类重载了父类的方法
    protected Person test(int i ) {
        return super.test();
    }

    /**
     * 重写父类的方法时，
     * 1）返回值类型
     *          如果返回值类型是基本类型时，子类方法的返回值必须与父类的一样
     *          如果返回值类型是类/接口时，子类方法的返回值类型必须可以自动转换为父类的类型
     * 2）权限修饰符
     *          子类无法重写父类的私有方法
     *          子类的权限修饰符访问范围必须大于等于父类的权限修饰符
     * @return
     */
    @Override
    protected Employee test() {

        return new Employee();
    }

    @Override
    protected long test1() {
        return super.test1();
    }
}

块和静态块

什么是块？

所谓的块就是指类中的{}

 //这就是块
    {
        //创建对象时，需要执行的一块代码（属性内存分配完成之后，构造方法执行之前）
        name = "wangshegnhui ";
        System.out.println("Person类的块");
    }
    public Person() {
        System.out.println("Person类的构造方法");
    }

Person类的块
Person类的构造方法

什么是静态块？

所谓静态块就是指类中使用static修饰的块

//这就是静态块
    static {
        //静态的都是直接属于类的，不需要依赖对象的创建
        //静态块是在JVM加载好类信息，创建好静态变量后执行
        System.out.println("Person类的静态块");

        //通常对静态常量进行初始化
    }

子类的静态块，块和构造方法，以及父类的静态块，块和构造方法。应该按照什么样的顺序执行？

先有父再有子

1、父类的静态块

2、子类的静态块

3、父类的块

4、父类的构造方法

5、子类的块

6、子类的构造方法