16、static关键字、接口
2024-05-10 04:02:45
Day16_static关键字、接口
1、static
1.1 static 修饰的静态代码块
1.1.1 代码块
{} 大括号里面的内容就是代码块1、构造代码块定义在类内
2、局部代码块定义在方法内
构造代码块演示
public class Person {private int id;private String name;private int age;/** 这就是构造代码块* 构造代码块 在成员变量之后 构造方法之前* * 特征：* 1、构造代码块在调用执行构造方法时一定运行* 2、构造代码块在调用执行方法之时 首先执行* * 构造代码块内容会在 Java 编译器编译过程中 直接给所有当前类的构造方法提供* 并且在所有的构造方法的 第一行* * 可以将构造方法相同的功能模块 使用构造代码块封装提供给所有构造方法 避免代码冗余*/{System.out.println("构造代码块");}public Person() {System.out.println("构造方法");}public Person(int id) {this.id = id;System.out.println("构造方法");}public Person(int id, String name) {this.id = id;this.name = name;System.out.println("构造方法");}public Person(int id, String name, int age) {this.id = id;this.name = name;this.age = age;System.out.println("构造方法");}public int getId() {return id;}public void setId(int id) {this.id = id;}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;}@Overridepublic String toString() {return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";}}局部代码块演示
public class Demo2 {public static void main(String[] args) {int num = 10;// 局部代码块 优化变量内存占用时间 提升代码内存效率 降低内存占用 {int num2 = 20;}System.out.println(num);//报错 num2 为局部变量//System.out.println(num2);}}1.1.2 static 修饰静态代码块基本语法和代码案例
//静态代码块要求在 class 大括号内
static {}
class SinglePerson {int num = 10;static int test = 20;/** 静态代码块* 只在类文件加载时执行一次* * 静态代码块只能当前类中使用 static 修饰的静态内容 不能使用非静态内容*/static {System.out.println("静态代码块");System.out.println(test);testStaticMethod();// System.out.println(num);
// test();}public void test() {System.out.println("非静态成员方法");}public static void testStaticMethod() {System.out.println("静态成员方法");}}public class Demo3 {public static void main(String[] args) {System.out.println("测试");SinglePerson singlePerson1 = new SinglePerson();SinglePerson singlePerson2 = new SinglePerson();}
}
1.1.3 静态代码块特征
1、static 修饰的静态代码块 之在程序的加载阶段执行一次
2、static 修饰的静态代码块 不能使用类内的非静态成员（成员变量和成员方法）
3、static 修饰的静态代码块 可以直接使用类内的静态成员（类变量和类方法）
4、static 修饰的静态代码块 用于项目的启动过程中的初始化操作可以利用 static 代码加载阶段执行的特征 将一些项目所需的配置操作前置用于 读取配置文件 加载相关驱动 加载第三方资源
1.2 static 题目
public class Demo4 {static Demo4 d1 = new Demo4();static Demo4 d2 = new Demo4();static {System.out.println("静态代码块");}{System.out.println("构造代码块");}public Demo4() {System.out.println("构造方法");}public static void main(String[] args) {Demo4 d = new Demo4();}
}
代码执行流程
1、从 main 方法进入程序 查找静态内容按顺序加载执行2、加载时执行静态成员变量 d1 赋值语句实例化 new一个构造方法 执行构造代码块和构造方法 依次执行打印语句
3、加载时执行静态成员变量 d2 赋值语句实例化 new一个构造方法 执行构造代码块和构造方法 依次执行打印语句
4、加载时执行静态代码块打印输出
5、执行 main 方法 new一个构造方法 执行构造代码块和构造方法 依次执行打印语句
代码执行结果
2、interface 接口
2.1 Java 中定义接口的格式
基本语法、格式规范和使用要求
关键字：interface
格式：
interface 接口名 {成员变量成员方法
}1、接口是一个特殊的类型 也是一个数据类型
2、接口名要求符合命名规则 见名知意 大驼峰命名法
3、接口类型变量 是一个引用数据类型变量
//接口的定义和实现/** 接口定义格式：* * interface 接口名 {* 成员变量;* 成员方法;* }* */
/** 自定义接口*/
interface A {/*** 成员变量* * 接口中的成员变量的【缺省属性/默认属性】 public static final* public 表示数据公开 任何位置都可以使用* static 静态修饰 * final 最终修饰/不可更改修饰* * 【带有名称的常量】下划线命名法 所有字母全大写 不同单词之间用 _ 连接*/int NUM = 1;/*** 成员方法* * 接口中的成员方法【缺省属性/默认属性】public abstract* public 表述方法公开* abstract 修饰 方法为抽象方法 没有方法体* */void test();/** 接口具体做什么 不是由本身决定 而是由继承接口的类决定*/
}
2.2 遵从接口
类遵从接口
关键字：implement
格式：
class 类名 implements 接口名 {}
/*** @author Echo** 类遵从接口* 格式：* class 类名 implements 接口名 {* * }* * 一个非 abstract 修饰类【遵从】接口 要求实现接口中的所有缺省属性为* public abstract 修饰的方法*/
class TypeA implements A{@Overridepublic void test() {System.out.println("TypeA 类遵从接口 A 实现 接口 A 中的 test 方法");}
}public class Demo1 {public static void main(String[] args) {//匿名对象直接调用方法new TypeA().test();//实例化对象之后 通过对象名调用方法TypeA typeA = new TypeA();typeA.test();}
}2.3 接口的特殊用法
2.3.1 类可以遵从多个接口
//一个类可以实现多个接口interface B {void testB();void test();
}interface C {void testC();void test();
}
/** TypeB 类同时遵从两个接口 分别是 interface B 和 interface C* 不同的接口直接使用 , + 空格 隔开* * 语法要求：* 1、遵从多个接口的类 要求分别实现每个接口中的方法* 2、如果多个接口中存在完全相同的方法声明 类中只实现一个方法即可*/
class TypeB implements B, C {@Overridepublic void testB() {System.out.println("TypeB 遵从接口 B 实现 testB 方法");}@Overridepublic void testC() {System.out.println("TypeB 遵从接口 C 实现 testC 方法");} public void test() {System.out.println("TypeB 遵从接口 B 和接口 C 实现两个接口中方法声明一样的方法【同规则方法】");};
}public class Demo2 {public static void main(String[] args) {TypeB typeB = new TypeB();typeB.test();typeB.testB();typeB.testC();}
}2.3.2 类可以继承父类同时遵从接口
//子类可以在继承父类的同时实现接口class SuperClass {public void test() {System.out.println("父类成员方法");}
}interface D {void testD();
}/*** * @author Echo* * 一个类可以在继承类的同时遵从接口*/
class TypeC extends SuperClass implements D {//【实现】接口 D 中的方法@Overridepublic void testD() {System.out.println("TypeC 遵从接口 D 实现 testD 方法");}//【重写】父类中的方法@Overridepublic void test() {System.out.println("TypeC 重写父类 SuperClass 的 test 方法");}
} public class Demo3 {public static void main(String[] args) {TypeC typeC = new TypeC();typeC.testD();typeC.test();}
}2.3.3 接口可以继承其他接口 并且可以多继承
//接口可以继承其他接口 并且可以多继承interface USB1_0 {void usb1_0Connect();
}interface USB2_0 {void usb2_0Connect();
}/*** * @author Echo** 接口可以继承其他接口 并且可以多继承*/
interface USB3_0 extends USB1_0, USB2_0 {void usb3_0Connect();
}/*** * @author Echo** 类遵从接口 要求实现接口中的所有的缺省属性/默认属性为 public abstract 修饰的方法* 包括当前接口的父类接口中的缺省属性/默认属性的方法*/
class TypeD implements USB3_0 {//实现 USB3_0 接口中的 usb1_0Connect 方法@Overridepublic void usb1_0Connect() {System.out.println("usb1_0Connect");}//实现 USB3_0 接口中的 usb1_0Connect 方法@Overridepublic void usb2_0Connect() {System.out.println("usb2_0Connect");}//实现 USB3_0 接口中的 usb1_0Connect 方法@Overridepublic void usb3_0Connect() {System.out.println("usb3_0Connect");}
}public class Demo4 {public static void main(String[] args) {TypeD typeD = new TypeD();typeD.usb1_0Connect();typeD.usb2_0Connect();typeD.usb3_0Connect();}
}2.3.4 JDK 1.8 版本以上特征
允许在接口中使用 default 关键字修饰方法 修饰的方法为默认方法 允许有方法体
//接口中的默认成员方法interface E {void test();/** default 关键字修饰的方法* 可以被重写 也可以直接用*/default void testDefaultMethod() {System.out.println("JDK 1.8以上版本允许的默认方法 default 修饰");}//接口中 static 修饰的成员方法可以通过 接口名调用static void testE() {System.out.println("静态成员方法");}
}class TypeE implements E {@Overridepublic void test() {System.out.println("TypeE 类遵从接口 E 只需要完成接口 E 中的缺省属性为 public abstract 的 test 方法");}//重写接口中 default 修饰的 默认成员方法@Overridepublic void testDefaultMethod() {System.out.println("TypeE 类遵从接口 E 重写接口中由 default 修饰的默认 testDefaultMethod 成员方法");}}public class Demo5 {public static void main(String[] args) {TypeE typeE = new TypeE();typeE.test();typeE.testDefaultMethod();//interface E 中的静态成员方法 通过接口名调用E.testE();}
}2.3.5 接口语法问题
1、接口中是否可以定义 static 修饰的静态成员方法？可以static 修饰的成员方法可以直接通过该接口名调用。2、一个方法是否可以同时使用 abstract 和 static 两个关键字修饰？不行abstract 关键字修饰的方法没有方法体static 关键字修饰的方法是在类文件加载阶段已经准备就绪 必须明确所有和执行相关的内容即 static 修饰的方法必须有方法体 abstract 修饰的方法必须没有方法体 两者无法合作
3、多态
3.1 父类引用指向子类对象
class Animal {}class Monkey extends Animal {}
class Tiger extends Animal {}
class Lion extends Animal {}public class Demo1 {public static void main(String[] args) {Animal animal = new Animal();//多态 父类引用指向子类对象Animal monkey = new Monkey();Animal tiger = new Tiger();Animal lion = new Lion();// Monkey monkey = new Monkey();
// Tiger tiger = new Tiger();
// Lion lion = new Lion();/** 【Java语法规范】* 一个方法的所需参数类型为父类类型 * 传入的对象类型除了该父类类型对象外还可以传入子类类型对象*/feedAnimal(animal);feedAnimal(monkey);feedAnimal(tiger);feedAnimal(lion);}/*** 喂食方法 所需参数是动物类对象* * @param animal Animal 动物类对象*/public static void feedAnimal(Animal animal) {/** getClass() 可以获取当前对象对应完整 包名.类名*/System.out.println(animal.getClass() + "来吃饭了~");}
}3.2 接口的引用指向遵从接口的实现类对象
/** 【语法规则】* 一个方法的所需参数为接口类型 * 方法实际参数要求是 实现接口的类的对象 或者是实现接口类的子类*/interface USB {/*** 要求所有的 USB 设备必须完成的方法 用于描述/实现当前设备的功能*/void connect();
}/*** 鼠标类 遵从 USB 接口 可以认为是一个 USB 设备* @author Echo*/
class Mouse implements USB {@Overridepublic void connect() {System.out.println("USB 设备——鼠标 控制光标操作");}
}/*** G502 继承 Mouse 类 间接遵从 USB 接口* G502 也是一个 USB 设备* @author Echo**/
class G502 extends Mouse {@Overridepublic void connect() {System.out.println("200RMB 鼠标 一个是G502 一个是其它");}
}/*** 键盘类 遵从 USB 接口 可以认为是一个 USB 设备* @author Echo*/
class Keyboard implements USB {@Overridepublic void connect() {System.out.println("USB 设备——键盘 输入设备");}
}/*** IKBC 继承 Keyboard 类 可以认为是一个 USB 设备* @author Echo**/
class IKBC extends Keyboard {@Overridepublic void connect() {System.out.println("IKBC：200-300RMB 性价比极高");}
}class PC {/** 电脑预留 USB 接口 用于连接 USB 设备* 认为电脑通过 USB 接口连接 USB 设备* 认为是一个方法*//*** PC 电脑类 USB 接口连接方法 方法所需参数是 USB 接口类型 所需要的实际参数是 USB 设备* @param usb*/public void usbInterfaceConnect(USB usb) {/** 实际执行对象是 USB 设备*/usb.connect();}
}public class Demo2 {public static void main(String[] args) {//实例化 PC 电脑类对象PC pc = new PC();//实例化鼠标和键盘 都是 USB 接口
// Mouse mouse = new Mouse();
// Keyboard keyboard = new Keyboard();//多态 接口的引用指向遵从接口的实现类对象USB mouse = new Mouse();USB keyboard = new Keyboard();//PC 电脑类 传递的参数为接口实现类的对象pc.usbInterfaceConnect(mouse);pc.usbInterfaceConnect(keyboard);//G502 是 Mouse 类的子类 也可以作为当前方法的实现类
// G502 g502 = new G502();//多态 接口的引用指向遵从接口的实现类对象USB g502 = new G502();//传递的参数是接口实现类 Mouse 类的子类对象pc.usbInterfaceConnect(g502);//IKBC 是 Keyboard 类的子类
// IKBC ikbc = new IKBC();//多态 接口的引用指向遵从接口的实现类对象USB ikbc = new IKBC();//传递的参数是接口实现类 Keyboard 类的子类对象pc.usbInterfaceConnect(ikbc);}
}3.3 引用数据类型之间的强制类型转换
class SuperClass {public String str = "父类成员变量";public void testA() {System.out.println("父类成员方法testA");}public void testB() {System.out.println("父类成员方法testB");}
}/*** SubClass 是 SuperClass 的子类* @author Echo**/
class SubClass extends SuperClass {public int num = 10;@Overridepublic void testB() {System.out.println("重写父类中的 testB 方法");};public void testC() {System.out.println("子类方法");}
}public class Demo3 {public static void main(String[] args) {//父类的引用数据类型变量指向一个子类对象【多态】SuperClass subClass = new SubClass();/** 虽然父类的引用存储的数据类型是一个子类 但是对外的类型是父类类型 * 无法直接使用子类的变量和非重写父类的方法 不能赋值给子类类型的另一个对象*///subClass.num = 20; 报错//subClass.testC(); 报错//SubClass sub = subClass; 报错/** 多态对象可以调用* 1、父类中的变量* 2、当子类中没有重写父类的方法 调用的是父类中的方法* 2、子类重写父类中的方法 调用的是子类重写的方法*/System.out.println(subClass.str);subClass.testA();subClass.testB();/** 使用强制类型转换 把父类引用对外的数据类型转为子类类型* 【强制类型转换】可行 安全 无丢失*/SubClass sub = (SubClass)subClass;System.out.println(sub.num);sub.testC();}
}16、static关键字、接口相关推荐
- 1.16 static关键字（静态变量和静态方法）
在类中,使用 static 修饰符修饰的属性(成员变量)称为静态变量,也可以称为类变量,常量称为静态常量,方法称为静态方法或类方法,它们统称为静态成员,归整个类所有. 静态成员不依赖于类的特定实例,被 ...
- Day16-01 P71 面向对象12什么是多态 P72 对象13：instanceof和类型转换 P73 static关键字详解 P74 抽象类 P75 接口的定义与实现 P76N种内部类
Day16-01 P71 面向对象12:什么是多态 //父类Person package com.oop.demo06;public class Person {public void run(){S ...
- 【java初学】static关键字和接口
文章目录 static关键字和接口 1. static关键字[重点] 1.1 static修饰静态成员变量 1.1.1 为什么要使用静态成员变量 1.1.2 静态成员变量从生活角度总结 1.1.3 s ...
- 抽象类实例化 使用原功能 c++_java 学习笔记 day08 final/static关键字、抽象类和接口...
1.final关键字 final修饰类:此类不能被继承 final修饰变量:则变量不能被修改,是常量 final修饰方法:父类的方法被final修饰时,不能被重写 2.static关键字 2.1被st ...
- 二、final和static关键字，接口和抽象类
fianl关键字的作用 final代表最终的意思,可以修饰成员方法,成员变量,类 final修饰类.方法.变量的效果 final修饰类:该类不能被继承(不能有子类,但是可以有父类) final修饰方法 ...
- “ static”关键字在课程中做什么？
具体来说,我正在尝试以下代码: package hello;public class Hello {Clock clock = new Clock();public static void main( ...
- java--面对对象之final关键字和static关键字
final 一.final的概念 继承的出现提高了代码的复用性,并方便开发.但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写.可是当子类继承了这些特殊 ...
- 一文带你入门C++，类与对象、6个默认成员函数、this指针以及static关键字。
C++98关键字:63个 一.命名空间规则(namespace) 1.命名空间可以解决函数.全局变量名重复的问题,包在不同的命名空间里的重复函数,实际就是两个完全无关的函数. 2.命名空间允许续嵌套: ...
- 【JavaSE】类和对象 (二) —— 封装、包以及 static 关键字
目录 1. 封装 1.1 封装的概念 1.2 访问限定符 2. 包 2.1 包的概念 2.2 导入包中的类 2.3 自定义包 2.3.1 包的基本规则 2.3.2 创建一个包 2.4 包访问权限--d ...
- Java学习（静态static关键字，数组工具类Arrays，数学相关工具类（绝对值，向上取整，向下取整），继承，super和this关键字，抽象）
2022/1/2 (1/6)Java学习 1.静态Static关键字概述 一旦用了static关键字,那么这样的内容不再属于对象自己,而是属于类的,所以凡是本类的对象,都共享同一份. 2.静态stat ...
最新文章
- 中国工程院谭建荣：人工智能应用得再好，最核心的算法不行，创新能力就不行丨MEET2021...
- python官网下载步骤64位-windows下载并安装Python的具体步骤
- 帷幕的帷是什么意思_“战斗民族”的鲜花礼品凭什么火遍全球？
- [翻译] ASP.NET Core 利用 Docker、ElasticSearch、Kibana 来记录日志
- linux系统安装显卡驱动卡顿,关于Ubuntu16.04上N卡驱动导致滚动屏幕卡顿问题
- Spring的两种代理方式：JDK动态代理和CGLIB动态代理
- 初识c语言教程,第1课C语言教程一： 初识C程序.doc
- 06Matplotlib数据可视化--6.1绘图基础
- 4种方案，帮你解决Maven创建项目过慢问题
- 推荐一个管理微信好友及微信群的微信机器人管理软件
- win32com excel转pdf
- python结合mysql 购物管理系统
- 倾角传感器和陀螺仪传感器的区别
- BIOS知识枝桠——简称释义(按名称排序）
- Torch常用函数详解T
- 高斯正算C语言程序,一个老师给的高斯投影正、反算c++源码(最新整理)
- vite+ts+vue3 知识点（全局组件，局部组件，递归组件）
- php soap 加符号报错,php soap错误获取http标头
- linux的su参数,linux su命令参数及用法详解
- MTK Secure Boot 2.1详细配置方案-终极版