一、类和对象加载
1.1 类加载时机
-
先找到class文件，执行文件中的内容，把对类的描述信息加载进内存
-
加载时机：
- 创建对象
- 创建子类对象
- 调用静态变量、方法
- Class.forName(类名)
1.2 对象创建流程【无继承】
-
静态数据
- 静态变量、方法、代码块
-
实例数据
- 实例属性、方法
-
构造
- 构造代码块、构造器
1.3 对象创建流程【有继承】
- 父类的静态数据
- 子类的静态数据
- 父类的实例数据、构造代码块、构造器
- 子类的实例数据、构造代码块、构造器
Human
package com.shine.load;
public class Human {
// 属性
String name = "Human-name";
static String info = "Human-info";
// 静态代码块
static {
System.out.println("Human静态变量"+info);
System.out.println("Human-静态代码块");
}
// 动态代码块
{
System.out.println("Human实例变量"+name);
System.out.println("Human-动态代码块");
}
// 构造器
public Human() {
System.out.println("Human-构造器");
}
// 方法
}
Student
package com.shine.load;
public class Student extends Human {
// 属性
String name = "Student-name";
static String info = "Student-info";
// 静态代码块
static {
System.out.println("Student静态变量:" + info);
System.out.println("Student-静态代码块");
}
// 动态代码块
{
System.out.println("Student实例变量:" + name);
System.out.println("Student-动态代码块");
}
// 构造器
public Student() {
System.out.println("Student-构造器");
}
// 方法
}
二、final
2.1 概述
- final意为最终的不可修改的
- 可以修饰类、方法、变量
2.2 final类
-
使用final修饰的类成为最终的类，不能被继承，没有子类
-
比如
- Math
- String
- System
- ... ...
2.3 final方法
- final修饰的方法成为最终的方法，可以被继承，不能被重写
- Cannot override the final method from MyMath
package com.shine.final666;
public class Demo01 {
public static void main(String[] args) {
MyNewMath math = new MyNewMath();
double sum = math.sum(3355, 5566);
System.out.println(sum);
}
}
/**
* final修饰的类成为最终的类，不能被继承，没有子类
*/
// class MyMath extends Math{}
class MyMath {
public final double sum(double a,double b) {
return a+b;
}
}
class MyNewMath extends MyMath{
public final double sum(double a,double b) {
return a+b;
}
}
2.4 final变量【掌握】
-
final修饰的变量只能赋值一次
-
基本类型
- 数值不能改变
-
引用类型
- 地址值不能改变
-
局部常量
- 直接赋值
-
实例常量
- 对象创建完成之前赋值【直接赋值、构造代码块、构造器】
-
静态常量
- 类加载完成之前赋值【直接赋值、静态代码块】
基本和引用类型常量
package com.shine.final666;
public class Demo02 {
public static void main(String[] args) {
/**
* final修饰变量
* final修饰的变量只能赋值一次
* final修饰的基本类型变量数值不能修改
* final修饰的引用类型变量地址值不能修改
*/
int num = 10;
System.out.println(num);
num = 20;
System.out.println(num);
final int i = 100;
System.out.println(i);
// i = 200; final修饰的变量只能赋值一次
// 引用类型
final Dog dog = new Dog();
dog.name = "道哥";
dog.age = 2;
System.out.println(dog.name + "===" + dog.age);
System.out.println(dog);
dog.name = "道哥666";
dog.age = 3;
System.out.println(dog.name + "===" + dog.age);
System.out.println(dog);
// dog = new Dog();
}
}
实例和静态常量
package com.shine.final666;
public class Cat {
// 静态常量在类加载完成之前赋值
static final String INFO;// = "猫猫";
static {
INFO = "小猫猫";
}
// 实例常量在对象创建完成之前赋值
final String TYPE;// = "猫咪";
{
// TYPE = "小猫咪";
}
public Cat() {
TYPE = "小猫咪";
}
}
三、接口
3.1 概述
- 使用interface修饰的内容成为接口
- 接口表示一种规范、能力、约定
- 接口没有具体实现，需要实现类来执行具体的操作
3.2 接口中内容【掌握】
属性
- 接口中的属性默认使用public static final修饰
- 接口的属性都是公开静态常量
方法
- 接口中的方法默认使用public abstract修饰
- 接口中的方法都是公开抽象方法
package com.shine.inter;
/**
* 使用interface声明的内容是接口
*/
public interface USB {
// 属性都是公开静态常量,默认使用public static final修饰
String USB_VOLTAGE = "5.0V";
public static final String USB_VERSION = "Version 2.0";
// 方法默认都是公开抽象方法,默认使用public abstract修饰
void usbPower();
public abstract void usbTransfer();
}
3.3 接口的创建和使用
package com.shine.inter02;
public class Demo01 {
public static void main(String[] args) {
/**
* 接口
* 游泳的能力
* 跳跃的能力
* 飞翔的能力
* 抽象类
* Animal
* 子类
* Dog
* Bird
*/
Dog dog = new Dog();
System.out.println(dog);
Swimable swimable = new Dog();
}
}
interface Swimable{
void swim();
}
interface Jumpable{
void jump();
}
interface Flyable{
void fly();
}
abstract class Animal{
String type;
String color;
int age;
String info;
public abstract void eat();
public abstract void sleep();
}
/**
* Dog类
* 继承Animal 获取到Animal中所有的属性和方法
* 实现了Swimable和Jumpable 获取到接口中的属性和方法
*/
class Dog extends Animal implements Swimable,Jumpable{
@Override
public void jump() {
}
@Override
public void swim() {
}
@Override
public void eat() {
}
@Override
public void sleep() {
}
}
/**
* Bird类
* 继承Animal 获取到Animal中所有的属性和方法
* 实现了Flyable 获取到接口中的属性和方法
*/
class Bird extends Animal implements Flyable {
@Override
public void fly() {
}
@Override
public void eat() {
}
@Override
public void sleep() {
}
}
3.4 接口和类的关系
类和类的关系
- 继承，单继承，多级继承
接口和接口的关系
- 继承，多继承
接口和类的关系
- 实现，多实现
3.5 练习
接口
TypeC
HeadPhone
Mic
Board
HDMI
SD
RJ45 网线接口
VGA
抽象类
Computer
实现类
MiComputer
MacBook
测试类
创建子类对象调用方法
3.6 接口的多态【掌握】
- 接口可以声明为引用类型，更自然的使用多态
- 接口声明的引用类型只能调用接口中的方法，不能调用实现类中独有的方法和属性
package com.shine.inter02;
public class Demo01 {
public static void main(String[] args) {
/**
* 接口
* 游泳的能力
* 跳跃的能力
* 飞翔的能力
* 抽象类
* Animal
* 子类
* Dog
* Bird
*/
/**
* 正常创建对象,把Dog对象看做是Dog类型的变量：把狗当做狗
* 能使用Dog中和Dog继承得到的所有属性和方法
*/
Dog dog = new Dog();
/**
* 多态方式创建对象
* 把Dog对象看做是Animal类型的变量：把狗当做动物
* 只能使用Animal中声明的属性和方法
* 如果Dog重写了方法，展示重写之后的效果
*/
Animal a = new Dog();
/**
* 多态方式创建对象：接口的多态
* 把Dog对象看做是会游泳的对象
* 只能调用Swimable中声明的属性和方法
* 如果Dog重写了方法，展示重写之后的效果
*/
Swimable swimable01 = new Dog();
/**
* 动态方式创建对象：接口的多态
* 把Bird对象看做是会游泳的对象
* 只能调用Swimable中声明的属性和方法
* 如果Bird重写了方法，展示重写之后的效果
*/
Swimable swimable02 = new Bird();
}
}
interface Swimable{
void swim();
}
interface Jumpable{
void jump();
}
interface Flyable{
void fly();
}
abstract class Animal{
String type;
String color;
int age;
String info;
public abstract void eat();
public abstract void sleep();
}
/**
* Dog类
* 继承Animal 获取到Animal中所有的属性和方法
* 实现了Swimable和Jumpable 获取到接口中的属性和方法
*/
class Dog extends Animal implements Swimable,Jumpable{
@Override
public void jump() {
}
@Override
public void swim() {
}
@Override
public void eat() {
}
@Override
public void sleep() {
}
}
/**
* Bird类
* 继承Animal 获取到Animal中所有的属性和方法
* 实现了Flyable 获取到接口中的属性和方法
*/
class Bird extends Animal implements Flyable,Swimable{
@Override
public void fly() {
}
@Override
public void eat() {
}
@Override
public void sleep() {
}
@Override
public void swim() {
}
}
3.7 接口和抽象类的异同
相同点
不同点
3.8 常量接口
package com.shine.inter03;
public interface Constant {
// 公司相关
String COMPANY_NAME = "XXX有限责任公司";
String COMPANY_ADDRESS = "";
// 域名 && 服务器
String URL = "http://www.xxx.com";
// 转发重定向
String DORWARD = "forward";
String REDIRECT = "redirect";
}
3.9 接口回调【熟悉】
1、Boss调用Worker.work方法
传入自己这个对象 + 任务信息
2、工人调用Boss监听的方法
boss.giveWork --> worker.work --> boss.onWorkFinish
OnWorkFinishedListener
package com.shine.inter04;
/**
* 监听工作完成情况
*/
public interface OnWorkFinishedListener {
void onWorkFinish(String info);
}
Boss
package com.shine.inter04;
/**
* Boss类
* 管理者
* 调用工人工作的方法
* 被调用监听的方法
*/
public class Boss implements OnWorkFinishedListener {
// 工人
private Worker worker;
/**
* 有参数的构造器
* @param worker
*/
public Boss(Worker worker) {
super();
this.worker = worker;
}
/**
* 给工人分配工作【调用工人工作的方法】
* @param workInfo
*/
public void giveWork(String workInfo) {
worker.work(this,workInfo);
}
@Override
public void onWorkFinish(String info) {
System.out.println("收到工人"+worker.getName()+"反馈信息:" + info);
}
}
Worker
package com.shine.inter04;
/**
* 工人
* 工作
* 给Boss反馈信息【调用Boss中监听的方法】
*
*/
public class Worker {
private String name;
public Worker(String name) {
super();
this.setName(name);
}
/**
* 工人工作的方法
* @param boss 分配任务的人
* @param workInfo 分配的任务
*/
public void work(OnWorkFinishedListener boss, String workInfo) {
System.out.println(this.name + "接到任务:" + workInfo + ",开始努力工作...");
// 反馈信息--回调
boss.onWorkFinish(workInfo + "已经完成25%");
boss.onWorkFinish(workInfo + "已经完成50%");
boss.onWorkFinish(workInfo + "已经完成75%");
boss.onWorkFinish(workInfo + "已经完成100%");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Demo01
package com.shine.inter04;
public class Demo01 {
public static void main(String[] args) {
/**
* 测试类
* Demo01
* 接口
* 监听工作完成状态【实现了接口的对象是管理者】
* 类
* Worker
* work 干活
* Boss【实现接口】
* 分配工作【调用工人工作的方法】
* 监听工作完成情况【被工人调用】
*/
// 创建对象
Worker worker = new Worker("张三");
Boss boss = new Boss(worker);
// 分配任务并监听任务情况
boss.giveWork("挖坑埋自己");
}
}
