Java学习日志-第13天

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量100 收藏
点赞数
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sec_90/article/details/122484166
版权 
package day_05._01_ClassRelation;

public class ClassRelation_01 {
	// 关联关系,成员变量保存了另一个类 对象引用
	// 关系是长期的
	A a = new A();
	public static void main(String[] args) {
		// 依赖关系,局部变量,保存另一个类 对象引用
		// 方法执行完,关系就不存在了
		A a = new A();
	}
}
// 类之间单继承
class A{}
class B extends A{}
interface C{}
interface D{}
// 接口之间多继承
interface E extends C,D{}
// 类和接口之间多实现
class F implements C,D{}
package day_05._01_ClassRelation;

public class ClassRelation_02 {
	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对象的生命周期会和Test对象的生命周期绑定
	// 当我们创建了多个Test对象的时候,一般也会创建多个Person对象
	// 由于该person对象是手动创建的,那么也就意味着,其他地方没有保存person的引用
	// 当test对象销毁时,该person对象也被视为垃圾数据,等待被回收
	// Person person = new Person();
	
	// 如果不手动创建,需要调用处传递,那就不一样了,此时尽管test对象销毁,那么调用处依然保存了person对象的引用
	// 那么 person就不会是垃圾数据,不用被回收,还可以继续复用
	Person person;
	public Test(Person person) {
		this.person = person;
	}
	
}
class Person{
	
}
package day_05._01_ClassRelation;

public class Student {
	private int id;
	private String name;
	private int age;
	private Teacher teacher;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Teacher getTeacher() {
		return teacher;
	}

	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}

}

package day_05._01_ClassRelation;

public class Teacher {
	private int id;
	private String name;
	private int age;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

}

package day_05._02_InnerClass;

/**
 * 成员内部类,可以看做成员变量
 * 
 * 内部类优点 : 可以访问外部类的私有化属性
 * 
 * @author SEC90
 * @Date 2022年1月13日 上午10:30:44
 */
public class OuterClass_01 {
	private static String s1 = "私有化静态变量";
	private String s2 = "私有化成员变量";

	// 成员内部类
	// 可以使用访问权限控制修饰符
	// 在成员内部类中不能有静态声明
	// 在成员内部类中,可以直接访问外部类所有属性
	// 内部类类名 编译之后 : 外部类类名$内部类类名
	class InnerClass {
		// static int i = 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();
	}
}

package day_05._02_InnerClass;
/**
 * 静态内部类 可以看做静态变量
 * 
 * 在静态内部类中,可以声明成员属性也可以声明静态属性
 * 
 * 在静态内部类中,无法直接访问外部类的成员属性,需要创建外部类对象访问才行
 * 
 * @author SEC90
 * @Date 2022年1月13日 上午10:40:01
 */
public class OuterClass_02 {
	private static String s1 = "私有化静态变量";
	private String s2 = "私有化成员变量";
	
	static class InnerClass{
		public static void m1(){
			System.out.println(s1);
			// System.out.println(s2);
		}
		public void m2(){
			System.out.println(s1);
			// System.out.println(s2);
		}
	}
	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();
	}
}

package day_05._02_InnerClass;

/**
 * 局部内部类可以看做局部变量 ,
 * 
 * 如果通过局部内部类访问外部方法中的局部变量的时候,该变量需要加final修饰,但是在1.8开始,final可以省略
 * 
 * 局部内部类,不能使用权限修饰符 也不能使用static
 * 
 * 局部内部类的类名为外部类类名$1内部类类名,假如内部类类名一样了,那么就是外部类类名$2内部类,以此类推
 * 
 * @author SEC90
 * @Date 2022年1月13日 下午2:06:40
 */
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;
		// age = 2;
		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();
	}
}

package day_05._02_InnerClass;

import java.util.LinkedList;

/**
 * 匿名内部类 : 在方法调用的时候,需要传入一个接口的实现类对象的时候,可以不写实现类,直接写一个匿名内部类
 * 
 * 类名为 外部类类名$1, 外部类类名$2 以此类推
 * 
 * @author SEC90
 * @Date 2022年1月13日 下午2:16:13
 */
public class OuterClass_04 {
	public static void test(IUserService userService) {
		userService.login();
	}

	public static void main(String[] args) {
		// UserServiceImpl userServiceImpl = new UserServiceImpl();
		// test(userServiceImpl);

		// 优点 少定义一个类,并且还能访问外部类中的私有化属性,
		// 缺点 : 无法复用
		test(new IUserService() {
			@Override
			public void login() {
				System.out.println("登陆成功");
			}
		});
	}
}

interface IUserService {
	public void login();
}

// class UserServiceImpl implements IUserService {
// @Override
// public void login() {
// System.out.println("登陆成功");
// }
// }
package day_05._03_Singleton;

public class Client {

	public static void main(String[] args) {
		System.out.println(Singleton_01.getInstance());
		System.out.println(Singleton_01.getInstance());
		System.out.println(Singleton_01.getInstance());
		System.out.println(Singleton_01.getInstance());
		System.out.println(Singleton_01.getInstance());
		System.out.println(Singleton_01.getInstance());
		System.out.println("====");
		System.out.println(Singleton_02.getInstance());
		System.out.println(Singleton_02.getInstance());
		System.out.println(Singleton_02.getInstance());
		System.out.println(Singleton_02.getInstance());
		System.out.println(Singleton_02.getInstance());
	}

}

package day_05._03_Singleton;

/**
 * 设计模式 : 就是在编码实践中,人们发现有很多的编码经常被用到,
 * 
 * 于是就总结出来,形成固定的结构,该结构一般代表了最佳的实现方式
 * 
 * 让当前类只能被创建一个实例化对象
 * 
 * 1 要控制创建对象的数量,也就意味着 不能让客户,直接操作构造方法
 * 			所以 需要构造方法私有化
 * 2 对外提供一个用于获取对象的方法
 * 			没有入参 , 出参是当前类类型 的静态方法
 * 
 * 3 创建一个静态变量,用来保存实例化之后的对象
 * 
 * 结合对象的创建时机不同,又分为两种情况
 * 		1 加载阶段就创建对象,称为饿汉模式
 * 		2 用到的时候,再创建对象,称为懒汉模式
 * 
 * @author SEC90
 * @Date 2022年1月13日 下午2:36:51
 */
public class Singleton_01 {
	private static Singleton_01 s = new Singleton_01();

	public static Singleton_01 getInstance() {
		return s;
	}
}

package day_05._03_Singleton;

/**
 * 		2 用到的时候,再创建对象,称为懒汉模式
 * 
 * @author SEC90
 * @Date 2022年1月13日 下午2:36:50
 */
public class Singleton_02 {
	private static Singleton_02 s = null;

	public static Singleton_02 getInstance() {
		if (s == null) {
			s = new Singleton_02();
		}
		return s;
	}
}

sec_90
关注
java进阶提高学习教程-13JVM与多线程.pptx
10-30
Java进阶学习教程中的第13章主要涵盖了JVM（Java虚拟机）和多线程两个核心概念。JVM是Java程序运行的基础，它负责解释执行字节码文件，并提供了Java语言的跨平台特性。Java程序通过JVM与操作系统交互，使得程序可以...
2022.01.13_Java学习总结_面向对象_4_类之间关系、内部类、设计模式
m0_46552030的博客
01-13 137
1. 类之间关系 1.1 继承 使用extends表示 类和类之间是单继承 接口和接口之间是多继承,多个用逗号隔开 // 类之间单继承 class A{} class B extends A{} interface C{} interface D{} // 接口之间多继承 interface E extends C,D{} 1.2 实现 类和接口之间是多实现,多个用逗号隔开 Class 类名 implements 接口,接口,....{} // 类和接口之间多实现 class F implements
Bean实例化（Instantiation）多种方式
doublepg13的博客
12-15 466
ServiceLoaderFactoryBean使用的是ServiceLoader，ServiceLoader默认读取的是/META-INF/services/下的文件，而value="org.example.factory.UserFactory"刚好就是文件名，从而serviceType获取到的是文件内存储的UserFactory的所有实现类全路径，通过ServiceLoader.load(getServiceType(), this.beanClassLoader)方法加载得到了bean对象。
Spring源码浅析之bean实例的创建过程(二)
狐言
09-03 470
Bean实例化的过程createBean方法doCreateBean方法createBeanInstance方法obtainFromSupplier方法instantiateUsingFactoryMethod方法autowireConstructor方法instantiateBean方法 在上一篇内容中，介绍了doGetBean方法的源码内容，知道了bean在创建的过程中，有三个范围，单例、多例、Scope，里面都使用到了createBean。下面本篇文章的主要内容，就是围绕createBean来进行展开
Spring中常见的bean创建异常
热门推荐
Zone
05-05 12万+
Spring中常见的bean创建异常1. 概述     本次我们将讨论在spring中BeanFactory创建bean实例时经常遇到的异常 org.springframework.beans.factory.BeanCreationException，下面我们将讨论并再现这些异常，同时给出解决方案。
Spring专题之Bean初始化源码分析（2）
weixin_34413357的博客
09-07 233
前言 这篇是Spring专题Bean初始化的第二篇，主要对bean初始化具体过程的源码分析。上篇博客Spring专题之Bean初始化源码分析（1）中我们对Spring如何开始初始化bean以及bena初始化的总体过程有了大致的了解，接下来就继续上篇博客的结尾处开始来分析初始化bean的具体过程。 Bean初始化 上篇博客中我们知道了Spr...
2024年java面试题-数据库MySQL面试题第三部分
04-22
- **第三范式**：在满足第二范式的基础上，要求非主键列之间不存在传递依赖。 #### 九、大规模数据表的分页查询策略 - **问题**：使用`LIMIT OFFSET`方式分页会导致越往后查询越慢。 - **解决方案**：基于当前页...
JAVA毕业设计-网上书吧
03-21
【标题】"JAVA毕业设计-网上书吧"项目是一个典型的基于Java技术的Web应用程序，旨在为用户提供一个在线浏览、搜索和购买书籍的平台。这个项目不仅涵盖了基础的网站功能，还可能涉及到用户登录注册、购物车管理、订单...
Java技术面试 ---- 框架.md
05-11
### Java技术面试 ---- 框架 #### 一、Mybatis #{} 和 ${} 的区别 在 Mybatis 中，#{} 和 ${} 是用来处理 SQL 语句中的动态参数的两种方式。 - **#{}**：这种方式可以有效地避免 SQL 注入问题。它的工作原理是将...
太平洋集团java笔试题-301DaysOfCode:这是我的#301DaysOfCode日志文件
06-13
第一天：2020 年 1 月 13 日 今天的进展：将缓冲的输入和输出文件提交到我的 java 初学者指南，并从 AWS 开始并制作存储桶来存储数据。 第 2 天：2020 年 1 月 14 日 今天的进展：将文件读取器和写入器文件提交给我...
死磕Spring系列：Bean实例化原理
一半的博客
04-14 698
1. BeanDefinition 大家都知道，在Spring IOC启动时，会扫描类的信息，将相关信息封装为BeanDefinition存入到beanDefinitionMap中，后续用其中的描述信息来生成bean。 那我们现在就来对怎样Spring是怎样去实例化一个bean做一个说明。 2. getBean 首先从AbstractBeanFactory类入手，因为它是IOC容器的顶层实现类，基本上都是用其中的getBean去获取bean的。 public Object getBean(String na
beanfactory内方法注释翻译
wlyang666的博客
12-22 277
/** * Used to dereference a {@link FactoryBean} instance and distinguish it from * beans <i>created</i> by the FactoryBean. For example, if the bean named * {@code myJndiObject} is a...
内部类和设计模式
better_zhang的博客
11-30 142
1、什么是内部类(Inner Classes) 在Java中，允许在一个类（或方法、语句块）的内部定义另一个类，成为内部类。内部类和外层封装他的类属于所属关系，一般只用在定义她的类或语句块之内，实现一些没有通用意义的功能逻辑，在外部引用它时必须给出完整的名称。 优点：使源代码更加清晰，减少命名冲突，提高可视性。 public class Out{ class Inner{ //这里定义了一个内部类。 } } 内部类特点...
Java开发中的23种设计模式详解之一：5种创建型模式
Alex ♋ 博客
05-23 7700
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
【5】依赖注入DI（Dependency Injection）
Kuber
11-29 474
6、依赖注入 概念 依赖注入（Dependency Injection,DI）。 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 . 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 . 构造器注入 之前已经讲过 Set 注入 （重点） 要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is . 测试pojo类 : Address.java package com.k
Spring Boot 学习和使用
cesske的博客
09-24 1123
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 129
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
JAVA学习资源大合集：从入门到精通
11. **《HeadFirst Java》中文第2版上册**：以独特的教学方式讲解Java，适合喜欢互动式学习的读者。 12. **Hibernate3.6.1官方中文核心手册**：Hibernate是Java领域常用的ORM框架，这份手册可以帮助开发者理解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值