Java_从入门到JavaEE_12+13

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量1.4k 收藏 19
点赞数 38
文章标签： java java-ee 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lv785/article/details/138681210
版权

一、内部类

  1. 理解：一个类中再声明另外一个类
  2. 分类：
    1. 成员内部类
    2. 静态内部类
    3. 接口内部类
    4. 局部内部类
    5. 匿名内部类

1.成员内部类

案例：创建成员内部类的对象，并调用方法

import com.lv.outter_inner_02.Outter.Inner;
public class Test {
	public static void main(String[] args) {
		Inner inner = new Outter().new Inner();
		inner.method();
	}
}
package com.lv.outter_inner_02;
//外部类
public class Outter {
	private 	String str1 = "属性1";
				String str2 = "属性2";
	protected 	String str3 = "属性3";
	public 		String str4 = "属性4";
	final 		String str5 = "属性5";
	static 		String str6 = "属性6";
	static final String str7 = "属性7";

	//成员内部类
	class Inner{
		String str1 = "成员内部类的属性";
		public void method(){
			System.out.println("成员内部类的方法");
			System.out.println(str1);//this.str1
			System.out.println(Outter.this.str1);
			System.out.println(str2);//Outter.this.str2
			System.out.println(str3);//Outter.this.str3
			System.out.println(str4);//Outter.this.str4
			System.out.println(str5);//Outter.this.str5
			System.out.println(str6);//Outter.str6
			System.out.println(str7);//Outter.str7
		}
	}	
}

总结：

  1. 创建成员内部类对象，必须先创建外部类对象，再创建内部类对象
  2. 成员内部类可以使用外部类所有的属性

2.静态内部类

案例：创建静态内部类的对象，并调用方法

import com.lv.outter_inner_03.Outter.Inner;
public class Test {
	public static void main(String[] args) {
		Inner inner = new Outter.Inner();
		inner.method();	
	}
}
package com.lv.outter_inner_03;
//外部类
public class Outter {	
	static 		String str1 = "属性1";
	static final String str2 = "属性2";
	//静态内部类
	static class Inner{		
		public void method(){
			System.out.println("静态内部类的方法");
			System.out.println(str1);//Outter.str6
			System.out.println(str2);//Outter.str7
		}
	}
	
}

总结：

  1. 创建静态内部类对象，不用创建外部类对象
  2. 静态内部类只能使用外部类的静态属性

3.接口内部类

案例：创建接口内部类的对象，并调用方法

import com.lv.outter_inner_04.Outter.Inner;
public class Test {
	public static void main(String[] args) {	
		Inner inner = new Outter.Inner();
		inner.method();	
	}
}
package com.lv.outter_inner_04;
//外部接口
public interface Outter {	
	//接口内部类
	//public static class Inner{
	class Inner{
		public void method(){
			System.out.println("接口内部类的方法");
		}
	}	
}

总结：

  1. 接口内部类就是静态内部类
  2. 接口内部类默认使用public static修饰

4.局部内部类

案例：调用局部内部类里的方法

package com.lv.outter_inner_05;
public class Test {
	public static void main(String[] args) {
		Outter outter = new Outter();
		outter.method();
	}
}
package com.lv.outter_inner_05;
//外部类
public class Outter {
	public void method(){		
		//局部内部类
		class Inner{
			public void innerMethod(){
				System.out.println("局部内部类里的方法");
			}
		}		
		//创建局部内部类对象
		Inner inner = new Inner();
		inner.innerMethod();
	}
}

总结：

  1. 局部内部类不能使用访问修饰符修饰（因为局部内部类的作用域就是在该方法内）
  2. 局部内部类使用到外部类方法里的变量，该变量在JDK1.8开始会自动变成常量

5.匿名内部类

案例：

package com.lv.outter_inner_08;
public class Test {
	public static void main(String[] args) {	
		A a = new A() {		
			@Override
			public void method() {
				// TODO Auto-generated method stub				
			}
		};	
		a.method();
	}
}
package com.lv.outter_inner_08;
public abstract class A {
	public abstract void method();
}

实现过程：

  1. 底层创建匿名类(Test01$1.class)，继承A类，重写method()
  2. 创建匿名类对象
  3. 将匿名类对象的内存地址赋值给父类的引用 – 多态

6.应用场景

  1. A类的对象只在B类中使用，并且A类使用到B类所有的属性 – 可以将A类设置为B类的成员内部类（常用）
  2. A类的对象只在B类中使用，并且A类使用到B类的静态属性 – 可以将A类设置为B类的静态内部类（常用）
  3. A类(抽象类)的子类只创建一次对象，就没必要去创建子类 – 直接使用匿名内部类（new A()）（常用）
  4. I1接口的实现类只创建一次对象，就没必要去创建实现类 – 直接使用匿名内部类（new I1()）（常用）
  5. A类的对象只在B类某个方法中使用 – 可以将A类设置为B类的局部内部类（少见）
  6. A类的对象只在I1接口中使用 – 可以将A类设置为I1接口的接口内部类（少见）

二、常用类

1.包装类/封装类

  1. 理解：包装类是8种基本数据类型对应的类

  2. 出现原因：

    ​ Java为纯面向对象语言（万物皆对象），但是8种基本数据类型不能new对象，破坏了Java为纯面向对象语言的特征，所以Java又为8种基本你数据类型分别匹配了对应的类，这种类叫做包装类/封装类

  3. 基本数据类型与引用数据类型继承关系

    基本数据类型引用数据类型继承关系
    byteByteObject.Number.Byte
    shortShortObject.Number.Short
    intIntegerObject.Number.Integer
    longLongObject.Number.Long
    floatFloatObject.Number.Float
    doubleDoubleObject.Number.Double
    charCharacterObject.Character
    booleanBooleanObject.Boolean

    注意：int类型对应的包装类是Integer，char类型对应的包装类是Character

  4. 以int为例：

    package com.lv.package_class;

public class Test {
public static void main(String[] args) {		
		//手动装箱：基本数据类型 转 引用数据类型
		int a = 100;
		Integer integer = Integer.valueOf(a);
		System.out.println(integer);		
		//手动拆箱：引用数据类型 转 基本数据类型
		Integer integer = new Integer(100);
		int b = integer.intValue();
		System.out.println(b);		
		
    //JDK1.5开始提供自动装箱和自动拆箱的特性		
		//自动装箱：基本数据类型 转 引用数据类型
		int c = 100;
		Integer integer = c;//底层实现：Integer.valueOf(i);
		System.out.println(integer);		
		//自动拆箱：引用数据类型 转 基本数据类型
		Integer integer = new Integer(100);
		int d = integer;//底层实现：integer.intValue();
		System.out.println(d);
		
		//将字符串转换为int
		String str = "123";
		int e = Integer.parseInt(str);
		System.out.println(e);
	}
}

    经验：学习包装类要举一反三

  5. 包装类(int为例)深入

    package com.lv.package_class;

public class Test {
	public static void main(String[] args) {
		
		Integer integer1 = Integer.valueOf(100);
		Integer integer2 = Integer.valueOf(100);
		System.out.println(integer1 == integer2);//true
		
		Integer integer3 = Integer.valueOf(200);
		Integer integer4 = Integer.valueOf(200);
		System.out.println(integer3 == integer4);//false
		
	}
}

    底层分析：

    在Integer中，有一个Integer的缓存类

    public static Integer valueOf(int i){
		
		if(i>=IntegerCache.low && i<=IntegerCache.higt){
			return IntegerCache.cache[i-IntegerCache.low];
		}
		return new Integer(i);
	}
private static class IntegerCache{	
		static final int low = -128;
		static final int higt = 127;
		static final Integer[] cache;
		
		static{
			cache = new Integer[higt - low + 1];
			
			int j = low;
			for (int i = 0; i < cache.length; i++) {
				cache[i] = new Integer(j++);
			}
		}	
	}

    当输入值超出范围时就会return新的Integer对象，

    这就是为什么System.out.println(integer3 == integer4);的结果为false。

2.字符串的类

  1. 分类：
    1. String
    2. StringBuffer
    3. StringBuilder
1.String的使用
  1. 案例以及分析：
package com.lv.string_class;

public class Test {
	public static void main(String[] args) {
		String str = "123abc";
		
		str = str.concat("DEF123");//concat在末尾追加，并返回新的字符串
		str = str.substring(2);//substring从开始下标处截取到字符串末尾，并返回新的字符串
		str = str.substring(1, 7);//substring从开始下标处(包含)截取到结束下标处(排他)，并返回新的字符串
		
		str = str.toLowerCase();//toLowerCase转小写，并返回新的字符串
		str = str.toUpperCase();//toUpperCase()转大写，并返回新的字符串

		//--------------------------------------------------------------------
		
		str = "   123   abc   DEF   123         ";
		
		str = str.trim();//trim去除首尾空格，并返回新的字符串
		str = str.replace('2', '6');//replace替换字符，并返回新的字符串
		str = str.replaceAll("163", "666888");//replaceAll替换字符串，并返回新的字符串
		str = str.replaceFirst("666", "7777");//replaceFirst替换第一次出现的字符串，并返回新的字符串
		str = str.replaceAll(" ", "");//去除空格（将空格字符串替换成空内容的字符串）
		
		System.out.println("判断两个字符串是否相同(区分大小写)：" + str.equals("7777888abcDEF666888"));
		System.out.println("判断两个字符串是否相同(不区分大小写)：" + str.equalsIgnoreCase("7777888ABCDEF666888"));
		
		System.out.println("判断字符串是否以某个字符串开头：" + str.startsWith("777"));
		System.out.println("判断字符串是否以某个字符串结尾：" + str.endsWith("666888"));
		
		System.out.println("查询出子字符串在字符串中第一次出现的下标：" + str.indexOf("88"));
		System.out.println("查询出子字符串在字符串中最后一次出现的下标：" + str.lastIndexOf("88"));
		
		System.out.println("获取指定下标上的字符：" + str.charAt(7));
		
		System.out.println(str);//7777888abcDEF666888
		
		//-------------------------------------------------------------
		
		//将其他类型转型成String
		System.out.println(String.valueOf(100));//int -> String
		System.out.println(String.valueOf(123.123));//double -> String
		System.out.println(String.valueOf('a'));//char -> String
		System.out.println(String.valueOf(true));//boolean -> String
		System.out.println(String.valueOf(new char[]{'a','b','c'}));//char[] -> String
		
		//将其他类型转型成String -- 简化版
		System.out.println(100 + "");
		System.out.println(123.123 + "");
		System.out.println('a' + "");
		System.out.println(true + "");
		
	}
}

  1. 深入——String拼接创建对象

    案例以及分析：

    package com.lv.string_class;

public class Test {
	public static void main(String[] args) {		
		String str1 = "abc";
		String str2 = "abc";
		System.out.println(str1 == str2);//true		
		//两个常量在编译时直接拼接
		String str3 = "ab" + "c";
		System.out.println(str1 == str3);//true		
		//两个常量在编译时直接拼接
		final String s1 = "ab";
		final String s2 = "c";
		String str4 = s1 + s2;//反编译：String str4 = "abc";
		System.out.println(str1 == str4);//true		
		//变量拼接，底层会创建StringBuilder对象
		String s3 = "ab";
		String s4 = "c";
		String str5 = s3 + s4;//底层实现：String str5 = (new StringBuilder(String.valueOf(s3))).append(s4).toString()
		System.out.println(str1 == str5);//false	
	}
}
2.StringBuffer的使用

  1. 案例以及分析：

    package com.lv.string_class;
public class Test02 {
	public static void main(String[] args) {		
		//创建StringBuffer对象
		StringBuffer sb = new StringBuffer();		
		//在末尾追加字符串
		sb.append("123abc");
		sb.append("DEF123");		
		sb.insert(6, "XXYYZZ");//将字符串插入到指定下标的位置
		sb.setCharAt(6, 'x');//替换指定下标上的字符
		sb.replace(3, 6, "aabbcc");//替换开始下标处(包含)到结束下标处(排他)的字符串
		sb.deleteCharAt(3);//删除指定下标上的字符
		sb.delete(3, 17);//删除开始下标处(包含)到结束下标处(排他)的字符串
		sb.reverse();//反转字符串		
		System.out.println(sb.toString());//321321
	}
}

  2. StringBuffer的深入 – StringBuffer底层源码

    见StringBuffer底层源码分析

3.StringBuilder的使用

理解

  1. StringBuilder代表可变的字符序列。
  2. StringBuilder称为字符串缓冲区

工作原理：

  1. 预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
    StringBuilder是可变对象，这个是String最大的不同

深入：现在的需求要存储10000个长度的数据，不要使用new StringBuilder()的方式，因为使用无参构造，底层会创建16长度的容器，存储10000个数据需要多次扩容，效率极低，直接使用new StringBuilder(10000)的方式，一步到位。

4.StringBuffer和StringBuilder区别
  1. StringBuffer和StringBuilder在使用层面上是一模一样的（调用方法）
  2. StringBuffer和StringBuilder都是继承的同一个父类（AbstractStringBuilder）,而且底层实现都是依赖于父类
  3. 唯一不同就是StringBuffer方法上加了锁（synchronized），就意味着StringBuffer是线程安全的

应用场景：

  1. 单线程的程序：使用StringBuilder，因为不上锁
  2. 多线程的程序：使用StringBuffer，上锁是因为不让其他线程抢到资源

注意：StringBuilder的效率比StringBuffer高，因为没有上锁和解锁的过程

5.频繁的拼接字符串使用StringBuilder或StringBuffer

当频繁使用拼接字符串时：

String的底层实现：
str = str + “11223”;
str = new StringBuidler(String.valueOf(str)).append(“11223”).toString();

这样会导致内存占用过高。

静风残云
关注
Java_从入门到JavaEE_11
lv785的博客
05-08 1446
接口不可以new对象，接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象。接口里面的方法不一定都是抽象的，JDK1.8之前：接口中只能有静态常量和抽象方法，JDK1.8开始：接口中可以使用默认方法和静态方法。如果父类是抽象类，子类不一定实现父类的抽象方法，子类如果是抽象类，可以不实现父类的抽象方法。理解：实现类对象指向接口的引用（接口的引用中存储的是实现类对象在堆中开辟的地址）一个接口不可以实现多个接口，因为接口与接口的关系是多继承。
Java_从入门到JavaEE_04-1
lv785的博客
04-25 282
含义：具有特殊意义的字符本身。
Java_从入门到JavaEE_15
lv785的博客
05-14 1213
虽然使用其它的 Map 实现（如HashMap）也能完成枚举类型实例到值得映射，但是使用 EnumMap 会更加高效，因为它只能接收同一枚举类型的实例作为键值，并且由于枚举类型实例的数量相对固定并且有限，所以 EnumMap 使用数组来存放与枚举类型对应的值。尽管枚举看起来像是一种新的数据类型，实际上，枚举就是一种受限制的类，并且具有自己的方法。（枚举类编译时，没有把常量值编译到代码中，即使常量值发生改变，也不会影响引用常量的类 ）优点：这种枚举通过枚举嵌套枚举的方式，将枚举常量分类处理。
Java_从入门到JavaEE_14
lv785的博客
05-13 992
含义：用来描述或者匹配一系列符合某个语句规则的字符串案例：把一个字符串中带电话号码替换成111****1234总结：利用正则表达式对字符串进行替换，校验，分割，爬数据。常用表达式：见正则表达式常用表达式。
Java_从入门到JavaEE_19
lv785的博客
05-18 879
在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用出进行处理。JDK新特性，一个catch代码可以可以声明多个能处理的特定异常的类型，多个类型之间用”|”隔开。写catch代码时，先捕获的异常的范围不能大于后捕获的异常的范围。定义一个方法的时候，通过这种方式来告知调用方，我这个方法有可能会发生异常的。注意：此时抛出的是异常类型，并且抛出的异常类型是紧跟在方法名之后。当异常发生时，程序会中止当前的流程去执行相应的catch代码段。
Java_从入门到JavaEE_18
lv785的博客
05-17 364
JDK1.8版本的HashMap，数据结构是一维数组+单向链表+红黑树，获取hash值使用高16位^低16位，尾插法。多个key的hash值一样，意味着下标也是一样，在底层就会将多个key存储在一个单向链表里，效率极低。JDK1.7版本的HashMap，数据结构是一维数组+单向链表，获取hash值使用位移计算，头插法。因为不用的字符串的hash值有可能相同，会造成hash碰撞，所以hash种子数就应运而生了~~计算hash值是 数组长度-1 & key的hash值，2的幂长度会导致下标结果分布更加散列。
Java_从入门到JavaEE_08
lv785的博客
05-01 1021
Eclipse工具简绍Eclipse 是著名的跨平台的自由集成开发环境（IDE）。最初主要用来 Java 语言开发，但是目前亦有人通过插件使其作为其他计算机语言比如 C++ 和 Python 的开发工具。下载与安装下载：安装：因为Eclipse为绿色软件，直接解压缩运行.exe就行。打开问题：下载包一般不会出问题，Eclipse打不开一般有两方面的问题：电脑中JDK设置的环境变量有问题，Eclipse无法正确找到。下载的Eclipse版本，和电脑安装JDK版本不兼容。
Java_从入门到JavaEE_01
lv785的博客
04-24 238
​ 接受来自客户端的请求、处理业务、操作数据库、利用相应向客户端换回数据的技术叫做JavaEE.​ 1、JDK：Java开发工具包​ 2、JRE：Java运行环境。
Java_从入门到JavaEE_16
lv785的博客
05-15 1380
一、迭代器 1.Iterator 概念：Iterator是一个接口，它是集合的迭代器，集合可以通过Iterator去遍历集合中的元素，常用API接口： hasNext():如果迭代器中还有元素，则返回true。 next():返回迭代器中的下一个元素。 remove():删除迭代器新返回的元素。 案例：使用Iterator遍历元素 public class Test { public static void main(String[] args) { ArrayList<St
Java 从入门到精通全程笔记(JavaSE+JavaEE :史上最全笔记）
04-14
JavaSE+JavaEE企业级开发 全程笔记免费下载，内容详尽，doc文档,共173页,六号字体，双栏排版。 *、Java 基础， *、web， *、数据库（Mysql Oracle jdbc Hibernate hql/sql）， *、JSP， *、Ajax *、Struts， *、...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 323
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 390
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java分布式锁
juanmiao的专栏
10-12 699
每种方法都有其优点和适应的场景，数据库通常简单，但可能存在性能问题，redis非常快，但需要第三方库，并且可能引入网诺问题，Zookeeper提供了更复杂的同步原语，但需要额外学习曲线。分布式锁的实现比线程锁和进程锁要复杂得多，因为它需要在网诺中的多个节点之间进行协调，以保证锁的唯一性和一致性。在实现分布式锁时，通常会有一个中心节点（或者称为锁服务），所有需要获取锁的节点都需要向这个中心节点申请。这个中心节点负责协调和管理所有节点的锁请求，确保锁的唯一性和一致性。创建临时节点，执行业务逻辑，释放锁。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 690
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 544
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 910
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 1014
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
spring task的使用场景
qq_40603125的博客
10-13 356
spring任务调度框架约定的时间。
代理模式、BigDecimal详解
Mr.W的博客
10-14 1067
BigDecimal可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过BigDecimal来做的。浮点数之间的等值判断，基本数据类型不能用 == 来比较，包装数据类型不能用 equals 来判断。想要解决浮点数运算精度丢失这个问题，可以直接使用BigDecimal来定义浮点数的值，然后再进行浮点数的运算操作即可​​// 0。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值