JAVA introductory system tutorial (7) Object-oriented (encapsulation 2)

1.Inner classes in Java

1) What is What about inner classes: An inner class (Inner Class) is a class defined in another class. Correspondingly, a class containing an inner class is called an outer class.

2) Why should one class be defined inside another class?

The main functions of inner classes are as follows:

1> Internal classes provide better encapsulation. You can hide the inner class within the outer class, and do not allow other classes in the same package to access the class

2> The methods of the inner class can directly access all data of the outer class, including private data

3> The functions implemented by internal classes can also be implemented using external classes, but sometimes it is more convenient to use internal classes

3) How many types of internal classes are there: member internal classes, static internal classes, methods Inner classes, anonymous inner classes

2. Member internal classes in Java

The most common of internal classes is member internal classes, also known as ordinary Inner class. Let’s look at the following code:

From the above code we can see how to use member inner classes:

1. The Inner class is defined in The inside of the Outer class is equivalent to the position of a member variable of the Outer class. The Inner class can use any access control characters, such as public, protected, private, etc.

2. The test() method defined in the Inner class can Directly access the data in the Outer class without being affected by the access control character, such as directly accessing the private properties in the Outer class a

3. After defining the member inner class, you must use the outer class object to create the inner class Object, but cannot directly new an inner class object, that is: inner class object name = outer class object.new inner class ();

4. After compiling the above program, you will find that two. class file

Among them, the second is the .class file of the external class, and the first is the .class file of the internal class, that is, the .class file of the member internal class is always like this: external class name $ internal class Name.class

In addition, friendly reminder:

1. The external class cannot directly use the members and methods of the internal class

You can create an object of the inner class first, and then access its member variables and methods through the object of the inner class.

2. If the outer class and the inner class have the same member variables or methods, the inner class will access its own member variables or methods by default. If you want to access the member variables of the outer class, you can use the this keyword. For example:

Example: The member inner class Inner is defined in the editor, and the attribute values ​​of the outer class and the inner class are output in the show method of the inner class.

3. Static inner classes in Java

Static inner classes are static-modified inner classes. The characteristics of this inner class are:

1) A static inner class cannot directly access non-static members of an outer class, but it can be accessed through new outer class().member

2) If the static members of the outer class are different from the members of the inner class If the names are the same, you can access the static members of the outer class through "class name.static member"; if the static members of the outer class and the member names of the inner class are different, you can directly call the static members of the outer class through "member name"

3) When creating an object of a static inner class, you do not need an object of an outer class. You can create it directly

Inner class object name = new inner class();

Example:

PS: Since the method inner class cannot be used outside the method of the outer class, the method inner class cannot use access control characters and static modifications symbol.

6. Documentation instructions

package example.make_api;

/**
 * 当前这个ArrayTool这个类是针对数组操作的工具类,里面提供了遍历数组以及获取数组的最大值和
 * 查找数组中第一次出现的索引这些功能
 * @author 梦竹
 * @version V1.0
 */
public class ArrayTool {
	/**
	 * 无参构造私有化的目的,是为了不让外界创建对象
	 */
	private ArrayTool() {
		
	}
	/**
	 * 当前这个方法是针对数组遍历的功能
	 * @param arr  是需要被遍历的数组
	 */
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int x = 0 ; x < arr.length ;x ++) {
			//判断
			if(x==arr.length-1) {
				System.out.println(arr[x]+"]");
			}else {
				System.out.print(arr[x]+", ");
			}
		}
	}
	/**
	 * 当前getMax方法是获取数组中最大值的方法
	 * @param arr  需要遍历的数组
	 * @return     返回到就是数组中的最大值
	 */
	public static int getMax(int[] arr) {
		//定义一个参照物,假设为最大值
		int max = arr[0] ;
		//遍历其他元素
		for(int x = 1; x < arr.length ;x ++) {
			//判断
			if(arr[x] > max) {
				max = arr[x] ;
			}
		}
		return max ;
	}
	/**
	 * 当前这个方法是查找数组的某个元素在数组中第一次出现的索引
	 * @param arr  
	 * @param value
	 * @return
	 */
	public static int getIndex(int[] arr,int value) {
		//假设找不到
		int index = -1 ;
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++) {
			//判断
			if(arr[x] == value) {
				//将当前x索引赋值给index
				index = x ;
				break ;
			}
		}
		return index ;
	}
}

package example.make_api;
/**
 * 需求:自定义一个数组,遍历数组
 * 制作文档说明书:
 * 		可以定义一个ArrayTool,数组操作的工具类
 * 		在工具类,必须文档注释,来让解析成文档
 * 		在数组工具类ArrayTool,提供遍历功能,获取最大值的,查找数组中某个元素第一次出现的索引
 * 
 * 
 * @author Administrator
 *
 */
public class ArrayDemo {

	public static void main(String[] args) {
		
		//定义数组,静态初始化
		int[] arr = {57,69,13,24,80} ;
		
		//测试
		//遍历功能
		ArrayTool.printArray(arr);
		//最大值
		int max = ArrayTool.getMax(arr) ;
		System.out.println("最大值是:"+max);
		//求元素在数组中第一次参出现的索引
		int index = ArrayTool.getIndex(arr, 13) ;
		System.out.println("索引是:"+index);
	}	

}

At this time, two class files are found

Delete package example.make_api

Win R outgoing dos

#Related articles:

The above is the detailed content of JAVA introductory system tutorial (7) Object-oriented (encapsulation 2). For more information, please follow other related articles on the PHP Chinese website!