一、类之间关系
1.继承
//类和类之间是单继承
class A extends Code{
}
interface B {
}
interface C{
}
//接口和接口之间是继承,多继承用逗号隔开
interface D extends B,C{
}
2.实现
//类和接口之间是实现,多个实现用逗号隔开
class E implements B,C{
}
3.依赖
//局部变量保存的是其他类的引用
//依赖关系
A a=new A();
//类和类之间是单继承
class A extends Code{
}
个人理解:一般是局部变量,生命周期不同,例:临时朋友,一旦一段关系结束那么就不再联系
4.关联
//成员变量保存其他类对象
//关联,也叫强依赖
A a=new A();
个人理解:一般是成员变量,生命周期相同,例:好朋友,什么时候联系都可以,不会影响关系
5.聚合
User user=new User();
new Code(user);
new Code(user);
new Code(user);
public Code(User user){
this.user=user;
}
个人理解:一个对象,内部是一个整体,没被其他地方储存,会互相影响,例:类似橙子,有一个地方破了整个就破了,一起死
6.组合
User user;
public static void main(String[] args) {
A a=new A();
new Code();
new Code();
new Code();
}
public Code(){
user=new User();
}
个人理解:一个对象,内部不是一个整体,被其他地方储存,不会互相影响,例:类似橘子,拿走一块不应影响其他的,不一起死
二、内部类
1.概述
概念:类体中的类叫内部类
当一个事物的内部还需要另一个完整的结构时,并且该结构又只对当前这个类提供服务,这种情况下,就不需要单独创建实体类,只要把这个实体类写在这个类的内部就行
内部类可以访问外部类的私有化属性
内部类的类名=外部类的类名$内部类类名
class A{class B{}}
此时编译后生成的class文件B的名字叫A$B
2.成员内部类
成员内部类可以看做成员变量,类体中没有static修饰,成员内部类可以使用权限修饰符
成员内部类中不能有静态声明
成员内部类可以直接访问外部类中所有的属性
public class Code {
private static int a2=1;
private int b2 =2;
private class InnerClass {
int b2=3;
public void m2(){
System.out.println(a2);
System.out.println(b2);
//区分外部类和内部类同名的成员属性
System.out.println(Code.this.b2);
}
}
public static void main(String[] args) {
//创建外部类对象
Code out =new Code();
//创建成员内部类对象
InnerClass inner=out.new InnerClass();
inner.m2();
}
3.静态内部类
静态内部类可以看做静态变量,需要用static修饰
静态内部类中可以声明静态也可以声明成员
但是在静态内部类中,无法直接访问外部类的成员属性,需要创建对象
public class Code {
private static int a3=1;
private int b3=2;
//静态内部类
private static class InnerClass2{
public static void m3(){
System.out.println(a3);
}
public void m4(){
System.out.println(a3);
System.out.println(new Code().b3);
}
}
public static void main(String[] args) {
//可以直接new内部类对象
InnerClass2 inner2=new InnerClass2();
inner2.m4();
InnerClass2.m3();
}
4.局部内部类
局部内部类可以看做局部变量
局部内部类不能有静态声明
局部内部类的名字为外部类类名$1内部类类名
如果局部内部类名字相同,则为外部类类名$1内部类类名,外部类类名$2内部类类名,…
如果内部类访问外部方法中的局部变量,则该变量需要加final修饰,不可以二次复制,从1.8开始final可以省略
public class Code {
private static int a4=1;
private int b4=2;
public static void m5(){
int c4=3;
//局部内部类
class InnerClass3{
public void m6(){
System.out.println(a4);
System.out.println(c4);
}
}
//使用局部内部类也只能在这个方法中使用
InnerClass3 inner3=new InnerClass3();
inner3.m6();
}
public void m7(){
class InnerClass3{
public void m6(){
System.out.println(a4);
//成员方法的局部内部类,可以直接访问外部成员属性
System.out.println(b4);
}
5.匿名内部类
匿名内部类的类名为外部类类名$1,…
一般在方法调用时,需要传入一个对象的时候(一般是接口实现类对象),这时如果这个类也不会复用,就可以不创建class类,直接传入一个匿名内部类即可
语法: 方法名 (new 父类/父接口(){匿名内部类的类体});
匿名内部类就是一个子类,就是不创建对应的子类文件,直接创建一个临时使用的子类对象
匿名内部类数不能进行复用的
静态内部类中不能有静态声明,但是可以声明常量
不能直接访问外部的成员属性,需要有对象才行
test(new IUserService() {
@Override
public void login() {
System.out.println("登陆成功");
}
});
//1.8新特性,lambda表达式,也叫箭头函数,是匿名内部类的简写形式
test(()->System.out.println("登陆成功"));
public static void test(IUserService userService){
userService.login();
}
interface IUserService{
public void login();
}
三、设计模式
1.概述
设计模式代表了最佳的实践方式
软件设计模式又称设计模式,是一套被反复使用的、多人知晓的、经过分类编目的代码设计经验的总结
使用设计模式是为了可重用代码,让代码更容易被他人理解,保证代码可靠性,程序的重用性
2.单例模式
2.1.概述
让某个类只创建一个对象,提供一个获取对象的方法,调用多次,得到的对象是同一个对象
- 构造该方法私有化,不能让外部直接访问
- 需要提供一个用于获取对象的静态方法
- 提供一个用于保存对象的静态变量
根据对象的创建时机可分为两种
- 饿汉模式:类加载后立即创建对象
- 懒汉模式:第一次获取对象时,在创建对象
2.2.懒汉模式
//静态变量在类加载时进行初始化赋值,类生命周期中,只会加载一次并且初始化一次
static Code2 c6=new Code2();
private Code2(){
}
public static Code2 getInStance1(){
return c6;
}
2.3.饿汉模式
private Code2(){
}
private static Code2 c7=null;
public static Code2 getInStance2(){
if (c7==null) {
c7 =new Code2();
}
return c7;
}