JavaSE基础
文章目录
一、类和对象加载
1.1 类加载时机
- 先找到class文件,执行文件中的内容,被对类的描述信息加载都按内存
- 加载时机:
- 创建对象 new
- 创建子类对象
- 调用静态变量、方法
- Class.forName(类名)
1.2 对象创建流程【无继承】
- 静态数据
- 静态变量、方法、代码块
- 实例数据
- 实例属性、方法
- 构造
- 构造代码块、构造器
1.3 对象创建流程【有继承】
- 父类的静态数据
- 子类的静态数据
- 父类的实例数据、构造代码块、构造器
- 子类的实例数据、构造代码块、构造器
Human
package com.javastudy;
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.javastudy;
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-构造器");
}
// 方法
}
Main
package com.javastudy;
public class Main {
public static void main(String[] args) {
Student s = new Student();
}
}
Human静态变量Human-info
Human-静态代码块
Student静态变量Student-info
Student-静态代码块
Human实例变量Human-name
Human-动态代码块
Human-构造器
Student实例变量Student-name
Student-动态代码块
Student-构造器
二、final
2.1 概述
- final意为最终的不可修改的
- 可以修饰类、方法、变量
2.2 final类
- 使用final修饰的类成为最终的类,不能被继承,没有子类
- 比如
- Math
- String
- System
- … …
2.3 final方法
- final修饰的方法成为最终的方法,可以被继承,不能被重写
/**
* final修饰的类成为最终的类,不能被继承,没有子类
*/
class Sum01 {
public final double sum(double a,double b) {
return a+b;
}
}
class Sum02 extends Sum01{
// public final double sum(double a,double b) { //会报错
// return a+b;
// }
}
2.4 final变量
- final修饰的变量只能赋值一次
- 基本类型
- 数值不能改变
- 引用类型
- 地址值不能改变
- 局部常量
- 直接赋值
- 实例常量
- 对象创建完成之前赋值【直接赋值、构造代码块、构造器】
- 静态常量
- 类加载完成之前赋值【直接赋值、静态代码块】
基本和引用类型常量
package com.javastudy;
public class TestFinal02 {
public static void main(String[] args) {
/**
* final修饰变量
* final修饰的变量只能赋值一次
* final修饰的基本类型变量数值不能修改
* final修饰的引用类型变量地址值不能修改
*/
int num = 10;
System.out.println(num);
//没有用final修饰的变量值可以改变
num = 20;
System.out.println(num);
final int i = 100;
System.out.println(i);
// 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); //地址值不变
}
}
class Dog {
String name;
int age;
}
三、接口
3.1 概述
- 使用interface修饰的内容成为接口
- 接口表示一种规范、能力、约定
- 接口没有具体实现,需要实现类来执行具体的操作
3.2 接口中内容
属性
- 接口中的属性默认使用public static final修饰
- 接口的属性都是公开静态常量
方法
- 接口中的方法默认使用public abstract修饰
- 接口中的方法都是公开抽象方法
package com.javastudy;
interface TestInterface {
// 属性都是公开静态常量,默认使用public static final修饰
String Inter = "接口";
//public static final String USB_VERSION = "Version 2.0";
// 方法默认都是公开抽象方法,默认使用public abstract修饰
void Inter();
//public abstract void usbTransfer();
}
3.3 接口的创建和使用
package com.javatest;
public class Main {
/**
* 接口
* 游泳的能力
* 吃饭的能力
* 飞翔的能力
* 抽象类
* Animal
* 子类
* Dog
*/
public static void main(String[] args) {
Dog dog = new Dog();
dog.show();
dog.swim();
Swimable s = new Dog();
s.swim();
}
}
abstract class Animal{
String name ;
int age ;
String sex;
abstract void show();
}
interface Flyable{
void fly();
}
interface Swimable{
void swim();
}
interface Eatable{
void eat();
}
/**
* Dog类
* 继承Animal 获取到Animal中所有的属性和方法
* 实现了Swimable和Eatable 获取到接口中的属性和方法
*/
class Dog extends Animal implements Swimable,Eatable{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("Dog eat");
}
@Override
public void swim() {
// TODO Auto-generated method stub
System.out.println("Dog swim");
}
@Override
void show() {
// TODO Auto-generated method stub
System.out.println("Dog ");
}
}
3.4 接口和类的关系
类和类的关系
- 继承,单继承,多级继承
接口和接口的关系
- 继承,多继承
接口和类的关系
- 实现,多实现
3.5 接口的多态
- 接口可以声明为引用类型,更自然的使用多态
- 接口声明的引用类型只能调用接口中的方法,不能调用实现类中独有的方法和属性
public static void main(String[] args) {
/**
* 正常创建对象,把Dog对象看做是Dog类型的变量:把狗当做狗
* 能使用Dog中和Dog继承得到的所有属性和方法
*/
Dog dog = new Dog();
/**
* 多态方式创建对象
* 把Dog对象看做是Animal类型的变量:把狗当做动物
* 只能使用Animal中声明的属性和方法
* 如果Dog重写了方法,展示重写之后的效果
*/
Animal a = new Dog();
/**
* 多态方式创建对象:接口的多态
* 把Dog对象看做是会游泳的对象
* 只能调用Swimable中声明的属性和方法
* 如果Dog重写了方法,展示重写之后的效果
*/
Swimable swimable01 = new Dog();
}
3.6 接口和抽象类的异同
相同点
- 可编译成字节码文件
- 不能创建对象。
- 可以作为引用类型。
- 具备0bject类中所定义的方法。
不同点
- 所有属性都是公开静态常量,隐式使用public static final修饰。
- 所有方法都是公开抽象方法,隐式使用public abstract修饰。
- 没有构造方法、动态代码块、静态代码块。
3.7 常量接口
package com.shine.inter03;
public interface Constant {
// 公司相关
String COMPANY_NAME = "";
String COMPANY_ADDRESS = "";
// 域名 && 服务器
String URL = "";
// 转发重定向
String DORWARD = "forward";
String REDIRECT = "redirect";
}
3.8 接口回调
1、Boss调用Worker.work方法
传入自己这个对象 + 任务信息
2、工人调用Boss监听的方法
boss.giveWork --> worker.work
package com.javatest;
public class Main02 {
/**
* 测试类
* Demo01
* 接口
* 监听工作完成状态【实现了接口的对象是管理者】
* 类
* Worker
* work 干活
* Boss【实现接口】
* 分配工作【调用工人工作的方法】
* 监听工作完成情况【被工人调用】
*/
public static void main(String[] args) {
Worker worker = new Worker("SAN");
Boss boss = new Boss(worker);
boss.giveWork("Good Work");
}
}
/**
* 监听工作完成情况
*/
interface WatchWork{
void Watch(String workInfo);
}
/**
* Boss类
* 管理者
* 调用工人工作的方法
* 被调用监听的方法
*/
class Boss implements WatchWork{
private Worker worker;
public Boss (Worker worker) {
this.worker = worker;
}
/**
* 给工人分配工作【调用工人工作的方法】
* @param workInfo
*/
public void giveWork(String workInfo) {
worker.work(this,workInfo);
}
@Override
public void Watch(String workInfo) {
// TODO Auto-generated method stub
System.out.println("收到工人"+worker.getName()+"反馈信息:" + workInfo);
}
}
/**
* 工人
* 工作
* 给Boss反馈信息【调用Boss中监听的方法】
*
*/
class Worker{
String name;
public Worker(String name) {
this.setName(name);
}
/**
* 工人工作的方法
* @param boss 分配任务的人
* @param workInfo 分配的任务
*/
void work(WatchWork bossWatch ,String workInfo) {
System.out.println(this.name + "接到任务:" + workInfo + ",开始努力工作...");
}
// 反馈信息--回调
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}