static关键字和块和包机制和继承super

static关键字

static：关键字静态的

被static关键字修饰的内容为静态内容

成员是属于对象的跟随对象使用，应为成员在对象的堆内存空间中，static修饰的静态的内容是属于类，可以随类使用。

静态变量都是独一份的，不存在对象的堆内存中，在静态区中在类第一次加载完成之后就会初始化静态内容。

成员的需要创建对象才在对象堆中存在成员，没有对象就没有成员。

在静态的内容中可以直接使用静态内容，但是不能直接使用成员内容，需要跟随对象使用成员，在成员内容中可以直接使用静态也可以直接使用成员

public class StaticDemo01 {
    //成员位置 : 类中方法外部
    //成员变量
    int a = 10;

    //静态变量
    static String str = "哈哈";

    public static void main(String[] args) {
        //局部
        //static int i = 1; static不能修饰局部,只能修饰成员

        //测试静态内容的使用方式
        System.out.println(str);//当前类中类名可以省略
        System.out.println(StaticDemo01.str);
        StaticDemo01 sd = new StaticDemo01(); //当前类型对象
        System.out.println(sd.a);
        System.out.println(sd.str);

        System.out.println(Math.random());
        System.out.println(Math.PI);
    }

    /*
        成员方法 : 需要被对象调用,在成员方法中的成员变量,默认指代当前调用成员方法的对象的成员
     */
    public void test(){
        System.out.println(this.str);
        System.out.println(this.a);
    }
}

block：块

{ } ——>自成作用域。

{ }：方法中|语句块中——>局部代码块|普通语句块

​ 执行时机：跟随方法调用。

{ }：类中方法外部——>构造块

​ 执行时机：创建对象new的对象。

static{ }：类中方法外——>静态块

​ 执行时机：类第一次加载完毕之后初始化。

注意：构造代码先于构造器之前运行，当存在多个构造块，从上到下依次执行，多个静态块从上到下依次执行，静态块在类第一次加载完成之后执行，并且只执行一次。

顺序：静态块——>main——>构造块——>构造器

public class BlockTest02 {
	public static int  a = 0;
	{
		a = 10;
		System.out.println(" 3、非静态代码块执行a=" + a); //
	}	
	static {
		a = 6;
		System.out.println("1、静态代码块执行a=" + a); //
	}
	public BlockTest02() {
		this(a); //
		System.out.println("6、"+a);  //
		System.out.println("7、无参构造方法执行a=" + a); //
	}
	public BlockTest02(int n) {
		System.out.println("4、"+n); //
		System.out.println("5、"+a);//
	}
	public static void main(String[] args) {
		System.out.println("2、main"); //
		BlockTest02 tsc = new BlockTest02();
		//6 10 10 6 10 10

	}
}

包机制

包机制：为管理众多java文件

导包：指明使用java类位置

不需要导包的类：

​ 同包下的类

​ java.lang包下的内容不需要导包

导包的方式：

​ 使用类型的时候指定类型的权限定名.包名.类名只在当前这一次有效。

​ 使用import 包名.类名 导包。定义在类上面，导入一次当前类中都可以使用。

​ 模糊匹配 *：降低编译效率

​ 静态导入 import static 包名.类名.静态内容。

package package03;
//模糊匹配
import java.util.*;

//导入静态内容
import static java.lang.Math.PI;
//导入静态方法不要添加(),因为方法名()这叫方法的调用,执行方法中的代码
import static java.lang.Math.random;
public class ImportDemo01 {
    public static void main(String[] args) {
        //包名.类名: 权限定名
        java.util.Scanner sc = new java.util.Scanner(System.in);
        Scanner sc2 = new Scanner(System.in);
        List ls = new ArrayList();
        //静态变量
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);
        //静态方法
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
        System.out.println(random());
    }
}

private：私有的

数据不安全的情况下如：数据为负数，符合类型要求，但是不符合逻辑要求。

为了解决安全问题使用关键字private私有的：

​ 只能在当前类使用，外部类中无法使用

​ 私有的属性配合一套公共的访问方式一起使用：

​ 设置器：为私有的属性进行赋值 setter

​ 获取器|访问器：获取私有属性的值 getter

private是封装，封装不仅仅是private。

/*javabean: 泛指一系列的类模板类
        标准的javabean规范:
            1)类是公共的
            2)至少存在一个空构造
            3)属性私有化
            4)公共的访问方式 setter getter
            ...
 */
public class JavaBean05 {
    public static void main(String[] args) {
        Person p = new Person();
        //p.name = "久伴";
        //p.age = -18;
        p.setName("张三");
        p.setAge(19);

        System.out.println(p.getAge());
        p.code();

    }
}


class Person{
    //姓名
    private String name;
    //年龄
    private int age;

    //构造器
    public Person(){}

    //设置器
    public void setAge(int age){
        if(age<=0 || age>=150){
            System.out.println("年龄不合法!!!");
            return;
        }
        this.age = age;
    }

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

    //访问器
    public int getAge(){
        return age;
    }

    public String getName(){
        return this.name;
    }

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

    //码农
    public void code(){
        System.out.println(age+"的"+name+"正在敲代码!!!!!");
    }

}

继承

继承：子成父类

继承的目的： 为了提高代码的复用性。

​ 子类|派生类：继承父类的类。

​ 父类|基类|超类：被继承的类。

类：抽取对象的共性。

父类：抽取子类的共性定义在父类中

特点：

​ 子类一单继承父类，就有权使用父类中的成员。

​ 子类中定义子类独有的内容。

​ extends子类 是父类的延续，扩展。

​ 一个父类可以存在多个子类。

​ 单继承机制：一个子类只能存在一个父类。

​ 接口可以多实现。

单继承的优点：简单

单继承的缺点：不够灵活，不便于程序后期维护

public class ExtendsDemo01 {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.name = "老大";
        t.age = 60;
        t.subject = "英语";
        t.teach();
        t.sleep();

    }
}

//人  -->父类
class Person{
    public String name;
    public int age;

    public void sleep(){
        System.out.println("休息");
    }
}

//教师类 ->子类
class Teacher extends Person{
    public String subject; //学科
    public Teacher(){}

    //教学
    public void teach(){
        System.out.println("教书育人!!!");
    }

}

//学生类 ->子类
class Student extends Person{
    public int grade; //成绩等级


    public Student(){}

    //学习
    public void study(){
        System.out.println("学习");
    }

}

super关键字

super和this的区别：

this：

​ this指代对象，当前对象。

​ 构造器的首行调用本类中的其他构造器。

​ 区分局部与成员同名问题。

super：

​ super指代父类对象（子类内存中的父类对象）。

​ 在子类的构造器首行，调用父类构造器。

​ 如果没有显示调用父类的指定构造器，默认在子类构造器的首行调用父类的空构造。

​ this（）和super不能同时存在。

区分子父类中同名成员的问题：

​ 默认就近原则。

​ 指代父类的成员，需要通过父类对象调用父类成员 super。

​ 如果不存在同名问题，当成员变量|方法，如果找到父类成员，默认省略super，如果找到子类成员，默认省略this。

注意：在存在父类继承的前提下，创建子类对象“先父类后子类”，先创建父类对象，再创建子类对象。

this与super都不能使用在静态环境中。

public class SuperDemo01 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.test();
    }

}


class Fu{
    public String name = "ash";
    public int age = 18;

    /*public Fu(){
        System.out.println("我是父类空构造");
    }*/

    public Fu(int a){
        System.out.println("我是父类带参构造"+a);
    }
}

class Zi extends Fu{
    public String name = "Edd";

    //this调用当前类中的其他构造器
    public Zi(){
        this(1);
        System.out.println("我是子类空构造");
    }

    //子类构造器的首行super()调用父类中指定构造器
    public Zi(int i){
        super(10);
        System.out.println("带参构造器"+i);
    }

    public void test(){
        String name = "hahaha";
        System.out.println(name);  //就近原则
        System.out.println(this.name);  //Edd 当前类中的成员
        System.out.println(super.name);  //Ash  通过父类对象调用父类成员

        System.out.println(age);  //相当于省略了super.
    }
}

​