java学习day013

最新推荐文章于 2024-11-13 20:43:20 发布

晨辰星66

最新推荐文章于 2024-11-13 20:43:20 发布

阅读量734

点赞数 28

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/Hunshangmeng/article/details/140879255

版权

一.类关系

纵向的关系 : 继承,实现横向的关系 : 依赖,关联整体和局部 : 组成型整体和局部, 聚堆儿型的整体和局部

继承 : extends 类和类单继承 , 接口之间多继承,多个逗号隔开

class A{}
class B extends A{}
interface C{}
interface D{}
interface E extends C,D{}

实现 : 类和接口多实现,多个逗号隔开,通过关键字implements表示

class A implements C,D{}

依赖 : 一个类中的局部变量,保存了另一个对象.保存在方法中

public static void main(String[] args){
    //依赖
    A a = new A();
}

关联 : 又叫强依赖 ,一个类中的成员变量 ,是另一个对象.保存在类中方法外.

public class ClassRelation{
    //关联
    A a = new A();
}

聚合 : 整体和局部可以分类,各自具备独立的生命周期. 比如 A要保存B的引用,这个引用一般是别人给的,或传递的,反正不是自己创建的比如工厂模式,或者Spring中的IOC DI注入

public class Test_02 {
    public static void main(String[] args) {
        User u = UserFactory.getUser();
    }
}
class User {
}
class UserFactory {
    static User user = new User();
    public static User getUser() {
        return user;
    }

}

组合 : 又叫强聚合,整体和局部不可分离,局部不具备独立生命周期. 比如 A要保存B的引用,这个引用一般是自己创建的那么A销毁后,B也会随之销毁,成员垃圾数据

public class Test_02 {
    User user = new User();
    public static void main(String[] args) {
    }
}
class User {
}

二.内部类

2.1 概述

类中创建的类

public class A{
    class B{
    
    }
}

当一个事物的内部,还有一个部分需要一个完整的结构进行描述

public class A{
    Teacher teacher;
}
class Student{
    int id;
    int age;
    String name;
    // Student类需要一个完整的Teacher类,但此时所有的类都可引用Teacher ,此时Teacher还不是内部类  
    Teacher teacher;
}
class Teacher{
    int age;
    String name;
}

而这个内部的完整结构只对当前类提供服务,就可以写为内部类

public class A{
    //这样写会出错无法使用内部类
    Teacher teacher;
}
class Student{
    int id;
    int age;
    String name;
    Teacher teacher;
    //此时的Teacher类只能由Student类使用,这时候的Teacher类就为Student的内部类
    class Teacher{
       int age;
        String name;
    }
}

可以访问外部类的私有化数据

内部类可以使用权限修饰符, public private protected

内部类类名 : 外部类类名$内部类类名

Student$Teacher

2.2 分类

成员内部类,静态内部类,局部内部类,匿名内部类.

2.2.1 成员内部类

1.等同看做成员变量 , 没有使用Static修饰的内部类
2.成员内部类不能有静态声明(类本身不能使用Static修饰,内部的方法和变量也不能使用static修饰) 3.成员内部类中可以直接访问外部类的所有数据

public class OuterClass{
    private static int a = 2;
    private int b = 4;
    
    class InnerClass{
        //public static void m1(){}这样写会报错,不能出现Static
        int b = 1;
        public void m2(){
            System.out.println(a);
            //如果内部类也有一个成员变量b，则默认调用内部类的
            //如果内部类没有b,则直接写b就能调用外部类的成员变量
            System.outprintIn(b);
            //如果内部类成员变量和外部类成员变量命名冲突了
            //则可以通过下面方式访问外部类的b
            System.out.printIn(OuterClass_02.this.a);
        }
    }
    
    public static void main(String[] args){
        //创建外部对象
        OuterClass_02 out = new OuterClass_02();
        //创建内部对象
        InnerClass inner = out.new InnerClass();
        //调用内部类的m2方法
        inner.m2();
    }
}

2.2.2 静态内部类

1.静态内部类可以等同看做静态变量
2.静态内部类中,可以直接调用外部类静态属性
3.不能直接访问外部类的成员属性需要创建外部类对象才能调用
4.静态内部类中可以有任何声明

public class OuterClass{
    private static int a = 2;
    private int b = 4;
    
    static class InnerClass{
        public staic void m1(){
            System.out.println("静态方法");
        }
        public void m2(){
            System.out.println(a);
            //不能直接访问成员属性
            // System.out.printIn(b);直接引用会报错
            //创建对象才能访问成员属性
            System.outprintln(new OuterClass_03().b);
            System.outprintln("成员方法");
        }
    }
    
    public static void main(String[] args){
        OuterClass.InnerClass.m1();
        //调用当前类中的静态内部类,外部类类名可以省略
        InnerClass.m1();
        InnerClass inner = new OuterClass.InnerClass();
        //类名可以省略
        inner = new InnerClass();
        inner.m2();
    }
}

2.2.3 局部内部类

1.局部内部类可以看做局部变量(写在方法中)
2.局部内部类,不能使用static修饰
3.局部内部类中访问外部方法的局部变量时,该变量需要加final修饰,但是1.8中final可以省略
4.局部内部类不能有静态声明
5.如果多个方法中的局部内部类,类名不一致则为外部类类名$1内部类类名
6.如果多个方法中的局部内部类类名一致了,则为外部类类名$1内部类类名，外部类类名$2内部类类名...以此类推
7.局部内部类可以直接访问外部类的静态属性
8.如果是静态方法中的局部内部类,则无法直接访问外部类成员属性
9.如果是成员方法中的局部内部类,则可以直接访问外部类的成员属性

public class OuterClass{
    private static int a = 1;
    private int b = 2;
   
    //静态方法(可以不创建外部对象而直接调用,因此成员属性不能直接调用)
    public static m1(){
        //实际上c有final修饰,但是在1.8中可以省略,因此c的值是固定值不可修改
        int c = 0;
        class InnerClass{
            // 不能有静态声明
            // public static void m3(){};会报错
            public void m4(){
                System.out.println(a);
                // 不能访问外部类成员属性
                // System.out.println(b);
                System.out.println(c);
                // 访问外部方法局部变量,final可以省略,但是依然不能修改
                // c=2;
            }
        }
        // 局部内部类只能在外部方法中使用
        InnerClass inner = new InnerClass();
        inner.m4();
    }
    
    //成员方法(使用成员方法必须创建对象,因此可以使用成员属性)
    public void m2(){
        int c = 3;
        class InnerClass{
            // 不能有静态声明
            // public static void m3(){};
            public void m4(){
                System.out.println(a);
                // 能访问外部类成员属性
                System.out.println(b);
                System.out.println(c);
                // 访问外部方法局部变量,final可以省略,但是依然不能修改
                // c=2;
            }
        }
        // 局部内部类只能在外部方法中使用
        InnerClass inner = new InnerClass();
        inner.m4();
    }
    
    public static void main(String[] args){
        OuterClass out = new OuterClass();
        out.m2;
        m1();
    }
}

2.2.4 匿名内部类

1.类体是创建对象的子类
2.匿名内部类少定义一个类,但是不能复用
3.匿名内部类类名︰外部类类名$1以此类推
4.匿名内部类不能有静态声明,但是可以声明常量
5.不能直接访问外部类的成员属性

public class OuterClass {
    public static void main(String[] args){
        test(new IUserService(){
            //public static void m1(){}报错,不能有静态声明
            public void m2(){}
            public static final int a = 2;
            @Override
            public void login(String username, String password) {
                // TODO Auto-generated method stub
                System.out.println("登录成功");
            }
            
        });
    }
    
    public static void test(IUserService userService){
        userService.login("admin","root");
    }
}

interface IUserService{
    void login (String username,String password);
}

三.设计模式

3.1 概述

代表了最佳实践方式,通常被有经验的面向对象的软件开发工作人员采用是众多有经验的开发人家,经过很长时间的使用和错误总结出来的,用来解决一系列特定问题它不是语法规范,而且一套用来提高代码的复用性、可读性、可维护性、鲁棒性及安全性的解决方案目前比较成熟的有23种

3.2 单例模式

3.2.1 目的

多次获取,只创建一个实例化对象,获取到的是同一个对象

3.2.2 创建思路

1.构造方法私有化,让外部无法创建对象
2.对外提供一个用于获取对象的静态方法
3.提供一个静态变量,保存创建的对象

3.2.3 应用场景

1.当类的创建成本较高或实例化过程复杂时，适合使用单例模式。
2.当一个类需要在整个系统中提供唯一的全局访问点，如配置管理、数据库连接池等。
3.当需要频繁访问且无需多个实例的对象，如缓存、日志等。

3.2.4 两种模式

1.懒汉模式懒汉式属于一种延迟加载的单例模式，它的特点是在第一次使用时创建实例对象，而不是在类加载时就创建。

public static Singleton{
    private Singleton(){} 
    private static Singleton obj = null;
    
    public static Singleton getlnstance(){
        if(obj == null){
            obj = new Singleton();
        }
        return obj;
    }
}

2.饿汉模式饿汉式是一种在类加载时就创建实例的单例模式。它的特点是无论是否会被使用到，实例对象都在类加载时被创建。

public static Singleton{
    private Singleton(){} 
    private static Singleton obj = new Singleton();
    
    public static Singleton getlnstance(){
        return obj;
    }
}