学习笔记——day10（内部类 数组）

最新推荐文章于 2022-04-28 22:41:16 发布
最新推荐文章于 2022-04-28 22:41:16 发布
阅读量460 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 学习笔记 文章标签： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Katherine_c/article/details/96590500
本文详细介绍了Java中的内部类，包括普通内部类、静态内部类、局部内部类和匿名内部类，阐述了它们的使用方式及特点。同时，文章还讲解了数组的声明、初始化和不同类型数组的用法，包括静态数组和动态数组。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在这里插入图片描述

内部类

(定义在类里面的类称之为内部类)
1:生成的字节码文件的文件名称 内部类-> 外部类$内部类

普通内部类

  • a：外部类中如何使用内部类的属性以及方法
    在外部类中创建内部类对象 调用内部类功能、属性
  • b:内部类中使用外部类的属性以及方法
    可以直接使用
  • c:其它类中调用内部类中的属性和方法：
    1:
    a：导包 包名.外部类.内部类
    b：内部类类型 变量名= new 外部类对象().new 内部类对象
    Inner01 in = new Outer01().new Inner01();
    2:
    外部类.内部类 变量名= new 外部类对象().new 内部类对象
    Outer01.Inner01 in = new Outer01().new Inner01();
    代码
public class Test01 {
	public static void main(String[] args) {
		//创建外部类对象
		Outer01 out = new Outer01();
		out.method();
		// 创建inner对象
		Outer01.Inner01 in = new Outer01().new Inner01();
		
		int num = new Outer01().num;
		
		
	}
}


class Outer01{
	
	int num;
	public Outer01(){
		
	}
	public void method() {
		// 使用内部类中的属性
		Inner01 in = new Inner01();
		in.fun();
		System.out.println("outer method");
	}
	
	/* private */ class Inner01 {
		public Inner01() {
			
		}
		public void fun() {
			/*
			 * Outer01 out = new Outer01(); out.method();
			 */
			method();
			System.out.println("Inner fun");
		}
	}
	
	class Inner02{
		public Inner02() {
			
		}
		public void fun1() {
			//fun();
			System.out.println("Inner fun");
		}
	}
	
}

静态内部类：

  • 什么是静态内部类
    通过static修饰的内部类称之为静态内部类

  • a：外部类中如何使用静态内部类的属性以及方法
    创建对象，调用对象的属性以及方法

  • b:静态内部类中使用外部类的属性以及方法
    创建外部类的对象 调用对象的属性以及方法

  • c:其它类中调用内部类中的属性和方法：

  • 1:
    a：导包 包名.外部类.内部类
    （导包的顺序没有关系，包的目的就是导包）
    （静态导入，降低了可读性，不利于阅读）
    b：内部类类型 变量名= new 外部类. 内部类对象()
    Inner01 in = new Outer02.Inner01();

  • 2:
    外部类.内部类 变量名= new 外部类. 内部类对象()
    Outer01.Inner01 in =new Outer02.Inner01();
    代码

public class Test02 {
	public static void main(String[] args) {
		
		// 创建对象
		Inner01 inner = new Outer02.Inner01();
		inner.fun();
		
	}
}
class Outer02{
	
	int num;
	public Outer02(){
		
	}
	public void method() {
		new Inner01().fun();
		System.out.println("outer2 method"+Inner01.num);
	}
	
	static class Inner01 {
		static int num = 10;
		public Inner01() {
			
		}
		public void fun() {
			//new Outer02().method();
			System.out.println("Inner fun");
		}
	}
	
	public static void fun() {
		new Outer02().method();
	}
	
	
}

编写静态内部类完成单例模式创建

  • 线程安全问题： 天然线程安全

  • 延迟加载： 能做到延迟加载

  • 类何时被加载： 调用静态内容 创建对象

  • 类加载的时候 首先将静态内容加载大内存中

代码

public class Single {
	
	static class SingleHolder{
		private static Single single = new Single();
	}
	
	private Single() {
		
	}
	
	public static Single getInstance() {
		return SingleHolder.single;
	}
	
	public static void add() {
		
	}

	public static void main(String[] args) {
		/*
		 * Single s1 = getInstance(); Single s2 = getInstance(); System.out.println(s1);
		 * System.out.println(s2);
		 */
		Single.add();
		Single s1 = getInstance();
	}
}

局部内部类：

  • 定义在方法中的类 只能当前方法使用
  • 一定程度减少内存开销 但是复用性是及其低的

代码

public class Test03 {
	public static void main(String[] args) {
		
	}
	public static void info() {
		
		class Inner{
			
		}
		
	}
}

匿名内部类

两种比较的接口：
  • 内部比较器
    java.lang.Compareable 比较大小
  • 外部比较器
    java.util.Comparator

代码

public class Test01 {
	public static void main(String[] args) {
		
		//比较两个字符串的大小
		String str1 = "d";// String  char[] value = {'a','b','c','d'}
		String str2 = "aaaaaa";// char[] value = {'a','b','c','e'}
		
		//String中已经重写了comparTo方法 所以可以直接进行比较
		if(str1.compareTo(str2)>0) {
			System.out.println(str1);
		}else if(str1.compareTo(str2)==0) {
			System.out.println("相等");
		}else {
			System.out.println(str2);
		}
		
		//创建比较器对象
		MyCom m = new MyCom();
		int num = m.compare(str1, str2);
		if(num>0) {
			System.out.println(str1);
		}else if(num==0) {
			System.out.println("相等");
		}else {
			System.out.println(str2);
		}
		
		
	}
}

class MyCom implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		String str1 = (String)o1;
		String str2 = (String)o2;
		return str1.length()-str2.length();
	}
	
}

通过匿名内部类可以产生一个接口/抽象了的 实现类对象/子类对象
代码

public class Test02 {
	public static void main(String[] args) {
		
		//对于字符串按照字符串越短 越大
		Comparator com = new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				String str1 = (String)o1;
				String str2 = (String)o2;
				return -(str1.length()-str2.length());
			}
		};
		
		String str1 = "d";// String  char[] value = {'a','b','c','d'}
		String str2 = "aaaaaa";// char[] value = {'a','b','c','e'}
		
		System.out.println(com.compare(str1, str2));
		
		
		new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				/*
				 * String str1 = (String)o1; String str2 = (String)o2; return
				 * -(str1.length()-str2.length());
				 */
				return 1;
			}
		}.compare(str1, str2);
		
		
		//jdk 1.8之后 lambda表达式
		Comparator com1 = (x,y)-> 1;
		System.out.println(com1.compare(str1, str2));
		
		
		
		
		
		/* Comparator com2 = */
		new Comparator() {
			public int compare(Object o1,Object o2) {
				return 1;
			}
		};
		
		
		Comparator com3 = new Comparator() {
			public int compare(Object o1,Object o2) {
				return 1;
			}
		};
		
		
		
		
	}
}
abstract class T extends Test01{
	
}
策略模式：

有一个数组 数组中存储的是Emp(员工)对象，员工有姓名，年龄，工资。
1：将数组中员工的工资大于2000 小于5000的员工信息罗列出来
a：Emp类创建出来
代码

public class Test03 {
	public static void main(String[] args) {
		
		//通过带参构造器创建对象
		Emp emp1 = new Emp("张三",4500,22);
		Emp emp2 = new Emp("李四",3300,19);
		Emp emp3 = new Emp("王五",5555,33);
		Emp emp4 = new Emp("赵六",7632,18);
		Emp emp5 = new Emp("田七",2699,21);
		
		
		//声明一个emp数组
		Emp[] emps = new Emp[] {emp1,emp2,emp3,emp4,emp5};
		
		// 将数组中员工的工资大于2000 小于5000的员工信息罗列出来
		filterAge(null);
		
		
	}
	
	public static void filterSal(Emp[] emps) {
		//循环迭代emps
		for(int i = 0;i<emps.length;i++) {
			//获取数组中的每一个元素
			if(emps[i].getSal()>=2000 && emps[i].getSal()<=5000) {
				System.out.println(emps[i]);
			}
		}
	}
	
	public static void filterAge(Emp[] emps) {
		//循环迭代emps
		for(int i = 0;i<emps.length;i++) {
			//获取数组中的每一个元素
			if(emps[i].getAge()>=15 && emps[i].getAge()<=18) {
				System.out.println(emps[i]);
			}
		}
	}
}

public class Test04 {
	public static void main(String[] args) {
		//通过带参构造器创建对象
		Emp emp1 = new Emp("张三",4500,22);
		Emp emp2 = new Emp("李四",3300,19);
		Emp emp3 = new Emp("王五",5555,33);
		Emp emp4 = new Emp("赵六",7632,18);
		Emp emp5 = new Emp("田七",2699,21);
		
		
		//声明一个emp数组
		Emp[] emps = new Emp[] {emp1,emp2,emp3,emp4,emp5};
	
		
		// 创建一个过滤年龄的对象
		Filter filter = new FilterAge();
		
		filter.filter(emps);
		
	}
}

public class Test05 {
	public static void main(String[] args) {
		
		
		//通过带参构造器创建对象
		Emp emp1 = new Emp("张三",4500,22);
		Emp emp2 = new Emp("李四",3300,19);
		Emp emp3 = new Emp("王五",5555,33);
		Emp emp4 = new Emp("赵六",7632,18);
		Emp emp5 = new Emp("田七",2699,21);
		
		
		//声明一个emp数组
		Emp[] emps = new Emp[] {emp1,emp2,emp3,emp4,emp5};
			
		
		//filter(new FilterAge(),emps);
		
		
		Filter filter = new Filter() {
			
			@Override
			public void filter(Emp[] emps) {
				
				
			}
		};
		//filter(filter,emps);
		
		
		/*filter(new Filter() {
			public void filter(Emp[] emps) {
				for(int i = 0;i<emps.length;i++) {
					//获取数组中的每一个元素
					if(emps[i].getSal()>=2000 && emps[i].getSal()<=5000) {
						System.out.println(emps[i]);
					}
				}
			}
		},emps);*/
		
		
		filter((x)->{
			for(int i = 0;i<x.length;i++) {
				//获取数组中的每一个元素
				if(x[i].getSal()>=2000 && x[i].getSal()<=5000) {
					System.out.println(x[i]);
				}
			}
		},emps);
		
		new Emp();
		
	}
	
	public static void filter(Filter filter,Emp[] emps) {//Filter filter = new FilterAge()
		filter.filter(emps);
	}
}

数组

  • 什么是数组： 一组数 （数据） 的集合

  • 官方定义： 在内存中 通过连续的存储单元 存储相同数据类型的 有序集合

  • 如何定义数组：
    [] 代表数组出现了
    数据类型[] 变量名;

  • 如何初始化数组：
    变量名 = new 数据类型[数组的长度];
    arrs = new int[10]

  • 获取数组中的元素
    数组变量[索引]
    索引从0开始 到 长度-1 结束（数组的索引 从0开始 到 length-1结束）
    假设长度为10；那么根据索引获取元素 数组变量[0] - 数组变量[9]

  • 获取数组中的长度：数组变量.length

代码

public class Test01 {
	public static void main(String[] args) {
		
		// 声明一个数组
		int[] arrs;//声明了一个int类型的数组  该数组中只能存放int类型的数据
		
		
		String[] strs;
		
		
		// 数组的初始化
		arrs = new int[10];//初始化arrs 当前arrs这个数组可以存放5个int类型的数据
		
		
		//查看数组中的元素
		System.out.println(arrs[9]);


		// 数组中有一个很重要的属性  长度
		System.out.println(arrs.length);
		
		
	}
}

数组的声明以及初始化

  • //数组的声明
  • int arrs[];不建议使用

静态数组：

  • new 数据类型[]{元素1,元素2,元素3,…}
    {元素1,元素2,元素3,…};
  • 不能确定数组中存储的元素的

动态数组：

  • 初始只指定数组的长度 然后通过索引一次填充具体的值。

  • 打印数组对象：
    [Ljava.lang.String;@15db9742
    [ 代表数组对象
    java.lang.String 数据类型

  • 数组的长度是不可变的。

代码

public class Test02 {
	public static void main(String[] args) {
		//声明
		String[] strs;
		//初始化
		strs = new String[5];
		
		
		//数组的初始化  
		// 静态初始化  在创建数组时  已经确定数组中每个元素是什么
		int[] arrs = new int[] {1,12,123};//   声明数组时通过{} 将所有元素添加到数组在中
		
		//arrs重新赋值
		arrs = new int[10];
	
		
		// 静态初始化 
		int[] ars = {1,11,111};// 声明一个长度是3 的int类型的数组 存储元素1 11  111 
		ars = new int[3];
		System.out.println(ars);
		
		//声明一个数组
		String[] ss = new String[5];
		//通过索引一次给数组中的元素填充值
		ss[0] = "嘿嘿";
		ss[1] = "哈哈";
		ss[2] = "呵呵";
		ss[3] = "xixi";
		
		System.out.println(ss);
		
		
		int[] ins = new int[10];
		System.out.println(ins.length);
		ins = new int[20];
		System.out.println(ins.length);
		
	}/*
 *  0 1
 *  1 3
 *  2 5
 *  3 7
 *  n 2n+1
 *  
 *  增强for循环 只是用来获取元素的   迭代器
 *  	for(数据类型 变量名:取出数据的变量){
 *  	}
 *  	
 *  
 *  
 */
public class Test03 {
	public static void main(String[] args) {
		//  往数组中添加元素  1 3 5 7  。。。。。99奇数
		//1：声明一个数组
		int[] arrs = new int[50];
		
		//通过循环一次填充值
		for(int i = 0;i<arrs.length;i++) {
			arrs[i] = 2*i+1;
		}
		
		
		System.out.println("循环打印每个索引上的值");
		System.out.println("打印第一个位置上的元素："+arrs[0]);
		for(int i = 0;i<arrs.length;i++) {
			System.out.print(arrs[i]+"\t");
		}
		
		
		System.out.println("jdk1.5之后 推出了增强for循环");
		
		for(int arr:arrs) {
			System.out.println(arr);
		}
		
		
		
		
	}
}
}

`

Halcon学习笔记——Day2
Chris的博客
07-10 1198
8、通过dev_update_off关闭更新程序计数器、更新变量、更新图像窗口，可加快程序运行速度。9、dev_update_window 关闭或打开程序图像窗口 dev_update_var、dev_update_pc关闭或打开更新变量、更新程序计数器窗口。2、参数分别为：窗体句柄、显示的文本、使用的坐标系(window还是image)、文本所在行坐标、文本所在列坐标、文本颜色、文本是否有背景板。18、dev_open_window_fit_image：根据图像的宽高打开一个窗口。
Halcon学习笔记——Day1
最新发布
Chris的博客
07-09 2576
对于彩色图像，彩色图是用彩色相机取的图，使用分光镜将光线折射为红绿蓝三分量再用三个传感器接收，但实际使用时仍采用一个传感器，每个像元上仍然只有一个字节的电信号值，这种图称为Bayer图，通过插值算法得出每个像元上光照的三分量值，halcon内有算子将Bayer图转换为rgb彩色图。对于黑白相机，光线经过光电转换后，将光强信号转换成电信号，电信号用一个字节来表示该像元处的光强值，称该值为灰度值，也叫像素值、亮度值、强度值。十四、halcon内的图像坐标系：原点位于图像的左上角，纵向为行坐标，横向为列坐标。
JavaScript之内部数组
11-15 50
1、文档表单数组 文档中所有表单，构成的数组。 &lt;html&gt;&lt;head&gt;&lt;/head&gt;&lt;body&gt; &lt;form id="first"&gt;&lt;/form&gt; &lt;form id="second"&gt;&lt;/form&gt; &lt;form id=
十五、内部类、数组
blackcatlily的博客
04-22 218
一、内部类 （1）什么是内部类？ 在类的内部又定义了一个新的类，被称为内部类 （2）内部类的分类： 静态内部类：类似静态变量 实力内部类：类似实例变量 局部内部类：类似局部变量 1.匿名内部类 （1）是局部内部类的一种，因为没有名字得名 （2）想用一个接口先要用类实现，匿名内部类可以跳过用类实现这一步骤，之间在调用的时候new接口 二、数组 1.Java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object。 2.数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）。
数组与内部类
smcc11的博客
06-09 152
数组 可变参数（jdk1.5新增）--------方法的参数列表 要求：类型相同，个数可变（0~n个参数） 使用’…'表示可变参数 位置：必须存在与参数列表的最后 注意：编译器会为可变参数隐式构建一个数组,所在方法中使用可变参数,使用操作数组的方式操作可变参数 二维数组：数组中的嵌套 声明：数据类型[][] 数组名; 初始化： 动态初始化 : 先创建数组,后赋值 数据类型[][] 数组名 = new 数据类型[外层的长度][内层的长度]; 内层二维的长度: 规定了外层一维数组中每一个格子中的小数组的长度
java 对象数组，内部类
firedinner的专栏
12-27 974
※使用前必须先开辟空间，实例化 在一个类的内部还存在类，则称为内部类 ※内部类可以直接访问外部类的私有属性，这是内部类的最大特点 外部类.内部类    内部类对象 = 外部类对象.new内部类（）； ※内部类可以在方法中定义 ※内部类想访问方法中的参数，参数必须使用final关键字定义
数组排序：内部类
06-22 570
内部类顾名思义就是：在一个类内部再来一个类。 我们还是来改造MyCompare这个类，这是一个母类。 内部包含DescCompare和AscCompare分别代表 降序和升序排列。 实例化时先要有外部类对象，然才能有内部类的实例化。所以内部类里面也不能有啥静态方法 import java.util.Comparator;public class MyCompare{ // 降序
C#学习笔记——数组篇
Lcl_huolitianji的博客
08-06 1036
Unity3D数字孪生开发笔记（四）一、递归二、数组1>语法三级目录 一、递归 方法内部又调用自身的过程； 核心思想：将问题转移给范围缩小的子问题； 适用性：在解决问题过程中，又遇到相同问题； 优势：将复杂的问题简单化； 缺点：性能较差（cpu占用过多） 注意：存在堆栈溢出 二、数组 从Array类派生的，一组数据类型相同的变量组合； 一种空间连续的数据结构； 元素通过索引（位置的序号）进行操作。 1>语法 声明数组 数据类型[ ]  ~ 数组名 初始化数组 数
Java学习笔记——Number类
D77的博客
04-28 6528
目录 ​一、xxxValue() 二、compareTo() 三、equals() 四、valueOf() 五、toString() 六、parsexxx() 七、代码 Java中的抽象类Number类的子类包括：Byte、Short、Integer、Long、Float、Double。 Number类属于java.lang包。 下面简单介绍Number类中的方法。 一、xxxValue() byteValue()：以 byte 形式返回指定的数值。 shortValue()...
MLDn学习笔记 —— JDK新特性（枚举）
03-16
1. `values()`：返回枚举类型的全部常量数组，常用于遍历枚举。 2. `valueOf(String)`：根据字符串查找对应的枚举常量，若不存在则抛出`IllegalArgumentException`。 四、枚举与switch语句 枚举类型与Java的`switch...
java------内部类、数组以及可变参数的使用
qq_41899248的博客
06-05 450
内部类   类中定义类就是内部类。如果一个事物的成员也是一个事物，那么就可以使用内部类的定义。   常见的内部类有：成员内部类，局部内部类，私有内部类，静态内部类，匿名内部类（最重要的。） 成员内部类 内部类定义在外部类的成员位置。作为成员可以使用成员修饰符（public、private、default、protected、static、（不包括final）），作为类可以继承类，可以实现接口。...
Java数组与内部类
m0_64036990的博客
11-15 686
一、一维数组 相同数据类型有序的集合 作用：存储多个数据 特点：1、定长：长度一旦确定不可改变 2、存储相同数据类型的数据 3、有序、有索引 4、引用数据类型 数组长度：数组名.length 操作数组：根据索引操作数组 数组名（索引） ...
小白Java学习之路（包，内部类，数组）
qq_38114301的博客
07-19 218
包 文件夹，包没有子父级的关系。 作用 不同的包存储不同.java文件 增加了可读性以及后期的维护性 java中是以类为单位的，区分类，包名.类名 包的作用用来区分类 包的使用 使用package 包名 一定要注意 package语句在整个.java文件的第一行。 导包 java.lang包下的所有类都可以直接使用 不需要导包 如果需要导包： import 所需类的全限定名 ...
Java创建内部类数组并排序
hold_on_的博客
09-02 629
代码： import java.io.*; import java.util.*; import java.text.*; import java.math.*; import java.util.regex.*; public class Main { static class person{ int a; int b; double avege; //a和b的商 ...
18天Java学习---11.面向对象编程06-Java的内部类及对象数组
JXES智能生态系统
01-04 1871
1. Java的内部类机制 所谓内部类,是指在一个类的内部还有另外一个类的定义. 在Java中,可以在类的内部定义内部类, 也可以在方法内部定义一个类. 对于第一种形式,即类的内部定义一个新类,比较简单,举例如下: ? 1 2 3 4 5 6 7 8 9 10 ...
Java学习笔记---11.面向对象编程06-Java的内部类及对象数组
yuan123456789hui的博客
08-20 120
1. Java的内部类机制 所谓内部类,是指在一个类的内部还有另外一个类的定义. 在Java中,可以在类的内部定义内部类, 也可以在方法内部定义一个类. 对于第一种形式,即类的内部定义一个新类,比较简单,举例如下: view plaincopy to clipboardprint? class Outer //外部类 { pr...
第十一天日常更新--内部类&数组
weixin_45116848的博客
06-05 128
又到了日常更新的时候了,今天还是分享一些基础内容. 内部类 首先内部类就是类中定义类. 如果一个事物的成员也是一个事物,可以使用内部类来定义. 它分为5个大的方法 1.成员内部类 2.局部内部类 3.私有内部类 4.静态内部类 5.匿名内部类(重要) 成员内部类 内部类定义在外部类的成员位置 成员可以使用成员修饰符:public static …来修饰 类:可以继承,可以实现接口 Outer01$...
内部类的基本使用（用匿名内部类排序数组）
qq_39620599的博客
09-14 1365
package third; import java.util.Arrays; import java.util.Comparator; /**内部类外部类的基本使用 * 匿名内部类的基本使用（包括String数组排序） * * *///分别用接口和抽象类实现匿名内部类 abstract class AbstractClass{ int i; public AbstractC
Python数组操作与矩阵处理学习笔记
资源摘要信息:"本资源为Python学习笔记，内容涉及数组属性方法总结、数组与字符串的转换、生成数组的函数以及矩阵的相关知识。笔记内容丰富，涵盖了Python数组（主要指列表List和NumPy数组）的基本操作、属性、以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值