1. 类之间的关系
1.1 继承
使用extends表示;类和类之间是单继承;类和接口之间是多继承,多个用逗号隔开
class A{}
class B extends A{} 类之间单继承
interface C{}
interfaceD{}
interface E extends C,D{} 接口之间多继承
1.2 实现
类和接口之间是多实现,多个用逗号隔开
类实现接口后,必须实现所有的抽象方法,否则该类需要加abstract修饰
Class 类名 implements 接口,接口,.....{}
class F implementsC,D{}
1.3 依赖
在局部变量,保存另一个类,对象引用
方法执行完,关系就不存在了
public static void main(String[] args){
A a=new A();
}
1.4关联
成员变量保存了另一个类 对象引用,关系是长期的
public class A{
A a=new A();
}
1.5聚合
整体和局部都有独立周期
public class A{
public static void main(String[] args){
Person person=new Person();
Test t1=new Test(person);
System.out.println(t1.person);
Test t2=new Test(person);
System.out.println(t2.person);
}
}
class Test{
Person person=new Person(); 手动创建的对象,person对象的生命周期和Test对象 的生命周期绑定,没有保存person的引用,test对象销 毁,person对象当垃圾数据,等待回收
Person personal; 不手动创建的对象,调用处传递,当test对象销毁时
public Test(Person person){ 依旧保存了person对象的引用,person就不会当作
this.person=person; 垃圾数据回收,还可以继续复用
}
}
class Person{}
1.6组合
部分和整体不可分离
Person personal; 不手动创建的对象,调用处传递,当test对象销毁时
public Test(Person person){ 依旧保存了person对象的引用,person就不会当作
this.person=person; 垃圾数据回收,还可以继续复用
}
2. 内部类
2.1概述
当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,那么整个内部的完整结构最好使用内部类
在Java中,允许一个类的定义位于另一个类的内部,前者称为内部类,后者称为外部类。
Inner class一般用在定义它的类或语句块之内,在外部引用它时必须给出完 整的名称。
2.2成员内部类
成员内部类,可以看做成员变量
优点:可以访问外部类的私有化属性
成员内部类可以使用访问权限控制修饰符
内部类类名编译之后:外部类类名$内部类类名
public class OuterClass_01 {
private static String s1="私有化静态变量";
private String s2="私有化成员变量";
class InnerClass{
//static int=2; 在成员内部类中不能有静态声明
public void m1(){
System.out.println(s1);
System.out.println(s2);
}
}
public static void main(String[] args) {
// 1 创建外部类对象
OuterClass_01 o = new OuterClass_01();
// 2 创建内部类对象
InnerClass inner = o.new InnerClass();
// 3 访问属性
inner.m1();
}
}
2.3静态内部类
静态内部类可以看作静态变量
在静态内部类中,可以声明成员属性也可以声明静态属性
在静态内部类中,无法直接访问外部类的成员属性,需要创建外部类对象访问才行
public class OuterClass_02 {
private static String s1 = "私有化静态变量";
private String s2 = "私有化成员变量";
static class InnerClass{
public static void m1(){
System.out.println(s1);
}
public void m2(){
System.out.println(s1);
}
}
public static void main(String[] args) {
// 调用m1
OuterClass_02.InnerClass.m1();
// 当前类中 类名可以省略
InnerClass.m1();
// 创建静态内部类对象
InnerClass inner = new OuterClass_02.InnerClass();
// 类名可以省略
inner = new InnerClass();
// 调用m2
inner.m2();
}
}
2.4局部内部类
局部内部类可以看做局部变量 ,
如果通过局部内部类访问外部方法中的局部变量的时候,该变量需要加final修饰,但是在1.8开始,final可以省略
局部内部类,不能使用权限修饰符 也不能使用static
局部内部类的类名为外部类类名$1内部类类名,假如内部类类名一样了,那么就是外部类类名$2内部类,以此类推
public class OuterClass_03 {
private static String s1 = "私有化静态变量";
private String s2 = "私有化成员变量";
public static void main(String[] args) {
}
// 静态方法中的局部内部类,无法直接使用外部类中的成员属性
public static void m1() {
final int age = 19;
class InnerClass {
// public static void m1(){}
public void m3() {
System.out.println(age);
System.out.println(s1);
// System.out.println(s2);
}
}
}
// 成员方法中的内部类,可以直接访问外部类中的所有属性
public void m2() {
final int age = 19; final可以省略,但age不能更改和二次赋值
class InnerClass {
// public static void m1(){}
public void m3() {
System.out.println(age);
System.out.println(s1);
System.out.println(s2);
}
}
// 局部内部类调用
InnerClass i = new InnerClass();
i.m3();
}
}
2.4匿名内部类
匿名内部类 : 在方法调用的时候,需要传入一个接口的实现类对象的时候,可以不写实现类,直接写一个匿名内部类
类名为 外部类类名$1, 外部类类名$2 以此类推
优点:少定义一个类,并且还能访问外部类中的私有化属性
缺点:无法复用
3. 设计模式
3.1概述
设计模式 : 就是在编码实践中,人们发现有很多的编码经常被用到,
于是就总结出来,形成固定的结构,该结构一般代表了最佳的实现方式
让当前类只能被创建一个实例化对象
1 要控制创建对象的数量,也就意味着 不能让客户,直接操作构造方法
所以 需要构造方法私有化
2 对外提供一个用于获取对象的方法
没有入参 , 出参是当前类类型 的静态方法
3 创建一个静态变量,用来保存实例化之后的对象
结合对象的创建时机不同,又分为两种情况
1 加载阶段就创建对象,称为饿汉模式
2 用到的时候,再创建对象,称为懒汉模式
3.2饿汉模式
public class Singleton_01 {
private static Singleton_01 s = new Singleton_01();
public static Singleton_01 getInstance() {
return s;
}
}
3.3懒汉模式
public class Singleton_02 {
private static Singleton_02 s = null;
public static Singleton_02 getInstance() {
if (s == null) {
s = new Singleton_02();
}
return s;
}
}