java基础之面向对象基础进阶day01
static关键字
static是一个修饰符，表示静态的意思，可以修饰属性、方法、代码块。它的主要作用是使得这些语法结构不再与对象实例相关，而是属于类本身，从而可以在不创建对象的情况下进行访问和调用。
静态成员
static修饰类中的数据成员，该成员就成了静态数据成员，也称为类成员；类成员，是属于类的，为这个类所有对象共享，只占用一块内存空间。它们的值可以被所有对象共享。静态变量在类加载时就已经被初始化，而且只会被初始化一次，直到程序结束或类被卸载。
static成员特点：
- 被类的所有对象共享。
- 随着类的加载而加载，先于对象存在。
- 对象需要类被加载后，才能被创建出来。
- 可以通过类名调用，也可以通过对象名调用，推荐使用类名调用格式： 类名.静态数据成员;
- 方法区中有一块专门的区域：静态区，专门用来存储类的static成员。
静态成员访问方式:
class Student {
public static int num;
}
public static void main(String[] args) {
//可以使用类名来访问，推荐用法
Student.num = 10;
Student stu = new Student();
//也可以对象来访问，但不推荐
stu.num = 20;
}静态数据成员是属于类的，并且为这个类所有对象共享
package 包名;
/**
* @author 谭梦寻
* @version 1.1
*/
class Demo {
public static int num;
}
public class TestStatic {
public static void main(String[] args) {
//1.静态数据成员会随着类的加载而加载（开辟内存并进行默认初始化）
//先于对象存在
Demo.num = 10;
//2.实例化两个对象，然后通过对象访问静态成员，输出其值
Demo demo1 = new Demo();
Demo demo2 = new Demo();
System.out.println(demo1.num);//输出结果为 10
System.out.println(demo2.num);//输出结果为 10
/* 可以看出，无论是使用类访问静态属性，还是使用这个类的某个对象访问静属性，
效果是一样的，这个属性对这个类的所有对象都是可见的、共享的。
静态属性的存储位置：
在方法区中有一块静态区，专门用来存储各个类静态数据成员。
当操作静态数据成员时，不论是通过类名，还是通过对象名操作，
都是操作静态区中对应的内存区域。
*/
//3.通过类名修改静态成员值，再借助对象.static成员，输出其值
Demo.num = 20;
System.out.println(demo1.num);//输出结果为 20
System.out.println(demo2.num);//输出结果为 20
//4.通过对象名修改静态成员值，再借助类名.static成员，输出其值
demo1.num = 30;
System.out.println(Demo.num);//输出结果为 30
System.out.println(demo2.num);//输出结果为 30
}
}
静态属性的存储位置：
在方法区中有一块静态区，专门用来存储各个类静态数据成员。当操作静态数据成员时，不论是通过类名，还是通过对象名操作，都是操作静态区中对应的内存区域 。
静态方法
在类中，使用static修饰的方法，就是静态方法。和静态变量一样，静态方法属于类本身，而不是对象实例。因此，静态方法可以直接通过类名来调用，而不需要先创建一个对象。
static方法的作用，主要是用来操作static成员；
静态方法案例：
class Demo {
public static int num;
public static void method() {
System.out.println("这是一个静态方法");
}
}
public class TestStatic {
public static void main(String[] args) {
//1.静态方法会随着类的加载而加载（开辟内存并进行默认初始化）
//先于对象存在
Demo.method();
Demo.num = 10;
//2.实例化对象，然后通过对象访问静态方法
Demo demo1 = new Demo();
demo1.method();
//两者执行的结果是一样的
}
}
static方法和普通成员方法区别：
- 静态方法只能访问静态的成员（因为静态先加载，非静态后加载，所以找不到非静态的内存空间地址）
- 非静态方法可以访问静态的成员，也可以访问非静态的成员
- 静态方法中是没有this关键字 （本质区别）
案例：
//学校类
class School {
private String name; //名称
private int num; //师生数量
//用private修饰static成员，则该类外无法直接访问该static成员
private static String library = "栋梁图书馆";
//定义public修饰的static方法，专门来操作static成员
public static String getLibrary() {
//注意1：static方法中没有this
//return this.library; //error
//注意2：static方法中不可以访问普通数据成员
//name = "一高"; //error
return library;
}
}
//测试方法
public static void main(String[] args) {
//1.在创建School对象前，输出 static成员值
//编译报错，library为private，只能School类内访问
//System.out.println(School.library);
//2.借助类名调用static方法，推荐用法
String lib = School.getLibrary();
System.out.println(lib);
//3.借助方法名调用static方法，不推荐
School s1 = new School("第一中学",3000);
System.out.println(s1.getLibrary());
}代码块
在Java中，使用 { } 括起来的代码被称为代码块，具体可以分为以下三类：
- 局部代码块
- 构造代码块
- 静态代码块
局部代码块
- 位置：在类的方法中定义
- 格式：{ 语句体 }
- 作用：用于限定变量的生命周期，使其尽早释放，从而提高占空间内存利用率
案例：
public class Test0104_LocalBlock {
public static void main(String[] args) {
//局部代码块
{
int a = 10;
System.out.println(a);
}
//上面局部代码块中的a是局部变量，遇到 } 其占用的内存空间就销毁了
//下面输出语句编译报错
//System.out.println(a);
}
}构造代码块
- 位置：类中方法外
- 格式： { 语句体; }
- 特点：每次构造方法执行前，都会先执行该代码块中代码
- 作用：如果多个构造方法中出现相同代码，可抽取到该块中，从而提高代码复用性 。
案例：
package com.briup.day07;
/**
* @author 谭梦寻
* @version 1.1
*/
public class TestConsBlock { //测试类
public static void main(String[] args) {
//实例化2个对象，观察程序输出效果：
//每次构造方法执行前，都会自动执行构造代码块
Module m1 = new Module();
Module m2 = new Module(10);
}
}
//基础类
class Module {
private int num;
//构造|匿名代码块
{
System.out.println("构造代码块: 构造方法执行前执行...");
}
//无参构造方法
public Module() {
System.out.println("Module() ...");
}
//有参构造方法
public Module(int num) {
System.out.println("Module(int) ...");
this.num = num;
}
}
静态代码块
- 位置：类中方法外
- 格式： static { 语句体; }
- 特点：需要通过static关键字修饰，随着类的加载而加载，只执行一次
- 作用：类加载时做一些数据的初始化操作（一般给static成员赋值）
案例：
class Teacher {
// 属性
private int id;
// 静态属性
private static String school;
// 代码块
static {
// 静态代码块
school = "希望小学";
System.out.println(school);//输出 希望小学
}
{
// 非静态代码块
this.salary = 3000;
}
}类的加载时机
加载类的含义：JVM虚拟机将该类的class文件加载到内存的方法区中。
当Java代码中用到某个类的时候，就会加载该类。
执行顺序：
- 先静态后动态
- 先代码块 后构造器
- 先默认赋值 后显式赋值
- 属性显式赋值和代码顺序由位置决定
案例：基础类
public class School {
private String name;
private static String library = "辽东图书馆";
private int num;
{
// 没有名字的代码块 只能创建对象时 自动调用
// 构造(创建对象)代码块 构造器 构造方法
System.out.println("构造代码块");
}
static {
// 静态代码块只加载一次：类加载只加载一次 jvm机只需要一次将该类加载
System.out.println("静态代码块");
// this不能放在静态代码块中
// 创建对象
// School school = new School();//可以
}
public School() {
}
public School(String name, int num) {
this.name = name;
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLibrary() {
return library;
}
public void setLibrary(String library) {
School.library = library;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public static void method() {
// 静态方法不能访问非静态属性 --》 类的加载机制 先加载类的信息，后对象信息
// 静态信息优先加载 故非静态属性和方法还未加载 不能直接访问
// 非静态方法可以访问静态方法和静态属性，当然 其他非静态的也能访问
// 静态方法中没有this关键字 this是对象，静态方法是类名调用 刚加载时没有对象 虽然也能通过对象访问，但不推荐
// System.out.println(num);//不能直接访问
System.out.println("这是一个静态方法");
}
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", num=" + num +
'}';
}
}
测试类：
public class TestSchool {
public static void main(String[] args) {
School school = new School("莲塘一中", 3000);
System.out.println(school.getLibrary());
// school.library //报错 私有属性不能直接访问
school.method();//不推荐
School.method();
School school1 = new School();
}
}
结果：
总结：
代码加载过程：先是静态，然后是非静态，最后是构造器。
继承
类和类之间的关系有很多中，继承就是其中一种关系，通过关键字extends实现。
固定格式
[public] class 子类名 extends 父类名 {
子类新增内容;
}继承的特点
- Java只支持单继承，不支持多继承。
- Java不支持多继承，但支持多重继承。如：子类 A 继承父类 B ，父类B 继承爷爷类 C
继承的细节和易错：
- 子类只能继承父类所有非私有的成员（含成员方法和成员变量，包括静态方法）
- Java中的类，如果类定义时没有指定父类，那么这个类会默认继承Object类
- Java中的每个类都直接或间接继承java.lang.Object(根基类)，Object类是Java继承体系中的最顶层父类。
- 当子类对象被创建时 (默认)会自动调用父类的无参构造器。
案例：
/**
* 继承了 Object(Object类没有父类 其他的都有父类，也都可以成为子类)
* 任何类都继承了java.lang.Object(根基类)
* 继承可以提高代码的复用性（不重复定义方法 使用父类的方法）
*/
public class Father {//extends Object
public int a;
private int b;
private void test() {
System.out.println("test");
}
public static void method1() {
System.out.println("这是父类的静态方法");
}
public void testA() {
System.out.println("testA");
}
}
class Son extends Father{
// 子类只能继承父类所有非私有方法和属性
public void method() {
System.out.println(a);//0
// System.out.println(b); //私有属性不可继承 故不可使用
}
public static void main(String[] args) {
Son son = new Son();
son.method();//输出0
// 静态方法也能被继承
son.method1();//这是父类的静态方法
System.out.println(son.toString());//继承了object中的toString()方法
}
}
super关键字
当从父类继承的非private成员，和子类新增的成员重名时，借助super关键字可以区分两个成员 。
super表示子类继承父类的那部分。
super内存图
super的注意事项
- super.属性只能放在第一行（意味着不能和this.属性关键字同时使用）
- super代表父类存储空间的标识（可以理解为父类对象引用）
- super()；显式地调用父类的无参构造器；super(参数)：调用父类有参构造器
代码展示：
public class Father {
public int id;
public Father() {
System.out.println("父类构造器");
}
public Father(int id) {
this.id = id;
}
public static void method1() {
System.out.println("这是父类的静态方法");
}
public static void main(String[] args) {
// 当子类对象被创建时 (默认)会自动调用父类的无参构造器
Son son = new Son();
System.out.println(son);
Son jack = new Son("jack", "北京");
System.out.println(jack);
Son joker = new Son("joker", "北京",1);
System.out.println(joker);
son.method1();
// joker.method();
}
}
class Son extends Father{
private String name;
private String city;
public Son() {
super();//显式地调用父类的无参构造器 可以不写，系统默认有
System.out.println("子类构造器");
}
// @Override
private void method() {
System.out.println("Son");
}
public Son(String name, String city) {
this.name = name;
this.city = city;
}
public Son(String name, String city,int id) {
super(id); //super调用父类构造器一定要放在第一行
this.name = name;
this.city = city;
// this.id = id;//或者super.id = id
}
@Override
public String toString() {
return "Son{" +
"id=" + id +
", name='" + name + '\'' +
", city='" + city + '\'' +
'}';
}
}运行结果： 