第十一章总结

最新推荐文章于 2024-06-09 18:24:15 发布
最新推荐文章于 2024-06-09 18:24:15 发布
阅读量113 收藏
点赞数
分类专栏： 总结 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62534787/article/details/124869489
版权

第11章 枚举与泛型

     枚举类型可以取代以往常量的定义方式，即将常量封装在类或接口中，此外，它还提供了安全检查功能。

     泛型的出现不仅可以让程序员少写某些代码，主要的作用是解决类型安全问题，它提供编译时的安全检查， 不会因为将对象置于某个容器中而失去其类型。

11.1 枚举

        枚举是一种数据类型，它是一系列具有名称的常量的集合。比如在数学中所学的合:A=123}，当使用这个集合时， 只能使用集合中的1、2、3 这3个元素，不是这3个元素的值就无法使用。

        Java中的枚举是同样的道理，比如在程序中定义了一个性别枚举，里面只有两个值:男、女，那么在使用该枚举时，只能使用男和女这两个值，其他的任何值都是无法使用的。

11.1.1 使用枚举类型设置常量

        以往设置常量，通常将常量放置在接口中，这这样在程序中就可以直接使用，并且该常量不能被修改，因为在接口中定义常量时，该常量的修饰行符为final与static。

        例如，在项目中创建 Constants接口，在接口中定义常量的常规规方式。

public interface Constants{

        public static final int Constants_A=1;

        public static final int Constants_b=12;

}

 在JDK 1.5版本中新增枚举类型后就逐渐取代了这种常量定义方式，因为通过使用枚举类型，可以赋予程序在编译时进行检查的功能。使用枚举类型定义常量的语法如下: 

public enum Constants{

        Constants_A,

        Constants_B,

        Constants_C

} 

 其中，enum 是定义枚举类型的关键字。当需要在程序中使用用该常量时，可以使用 Constants. Constants_A 来表示。

package l11;

interface Constants { // 将常量放置在接口中
	public static final int Constants_A = 1;
	public static final int Constants_B = 12;
}

public class ConstantsTest {
	enum Constants2 { // 将常量放置在枚举类型中
		Constants_A,
		Constants_B
	}

	// 使用接口定义常量
	public static void doit(int c) { // 定义一个方法，这里的参数为int型
		switch (c) { // 根据常量的值做不同操作
		case Constants.Constants_A:
			System.out.println("doit() Constants_A");
			break;
		case Constants.Constants_B:
			System.out.println("doit() Constants_B");
			break;
		}
	}

	public static void doit2(Constants2 c) { // 定义一个参数对象是枚举类型的方法
		switch (c) { // 根据枚举类型对象做不同操作
		case Constants_A:
			System.out.println("doit2() Constants_A");
			break;
		case Constants_B:
			System.out.println("doit2() Constants_B");
			break;
		}
	}

	public static void main(String[] args) {
		ConstantsTest.doit(Constants.Constants_A); // 使用接口中定义的常量
		ConstantsTest.doit2(Constants2.Constants_A); // 使用枚举类型中的常量
		ConstantsTest.doit2(Constants2.Constants_B); // 使用枚举类型中的常量
		ConstantsTest.doit(3);
		// ConstantsTest.doit2(3);
	}
}

 运行结果

11.1.2 深入了解枚举类型

        枚举类型较传统定义常量的方式，除了具有参数类型检测的优势之外，还具有其他方面的优势。

        用户可以将一个枚举类型看作是一个类，它继承于java.langEnum类，当定义一个枚举类型时，每一个枚举类型成员都可以看作是枚举类型的一个 实例，这些枚举类型成员都默认被final、public、static 修饰，所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。

        由于枚举类型对象继承于java.langEnum 类， 所以该类中一些操作枚举类型的方法都可以应用到枚举类型中。

枚举类型的常用方法
方法名称具体含义使用方法
values()该方法可以将枚举类型成员以数组的形式返回枚举类型名称.values()
valueOf()该方法可以实现将普通字符串转换为枚举实例枚举类型名称.valueOf("abc")
compareTo()该方法用于比较两个枚举对象在定义时的顺序枚举对象.compareTo()
ordinal该方法用于得到枚举成员的位置索引枚举对象.ordinal()

创建values()方法

package l11;

import static java.lang.System.out;

public class ShowEnum {
	enum Constants2 { // 将常量放置在枚举类型中
		Constants_A, Constants_B
	}

	// 循环由values()方法返回的数组
	public static void main(String[] args) {
		for (int i = 0; i < Constants2.values().length; i++) {
			// 将枚举成员变量打印
			out.println("枚举类型成员变量：" + Constants2.values()[i]);
		}
	}
}

运行结果 

valueOf()与compareTo()

     枚举类型中静态方法valueOf()可以将普通字符串转换为枚举类型，而compareTo()方法用于比较两个枚举类型成员定义时的顺序。调用 comparo eTo()方法时，如果方法中参数在调用该方法的枚举对象位置之前，则返回正整数;如果两个互相比较的枚举成员的位置相同，则返回 0;如果方法中参数在调用该方法的枚举对象位置之后，则返回负整数。

package l11;

public class EnumIndexTest {
	enum Constants2 { // 将常量放置在枚举类型中
		Constants_A, Constants_B, Constants_C
	}

	public static void main(String[] args) {
		for (int i = 0; i < Constants2.values().length; i++) {
			// 在循环中获取枚举类型成员的索引位置
			System.out.println(Constants2.values()[i] + "在枚举类型中位置索引值" + Constants2.values()[i].ordinal());
		}
	}
}

运行结果 

ordinal()

     枚举类型中的ordinal()方法用于获取某个枚举对象的位置索引值。

package l11;

import static java.lang.System.out;

public class EnumIndexTest {
	enum Constants2 { // 将常量放置在枚举类型中
		Constants_A, Constants_B, Constants_C
	}

	public static void main(String[] args) {
		for (int i = 0; i < Constants2.values().length; i++) {
			// 在循环中获取枚举类型成员的索引位置
			out.println(Constants2.values()[i] + "在枚举类型中位置索引值" + Constants2.values()[i].ordinal());
		}
	}
}

运行结果 

枚举类型中的构造方法

 在枚举类型中，可以添加构造方法，但是规定这个构造方法必须为 private 修饰符或者默认修饰符所修饰。枚举类型定义的构造方法语法如下:

package l11;

public enum Constants2{
    Constants_A("我是枚举成员A"),
    Constants_B("我是枚举成员B"),
    Constants_C("我是枚举成员C"),
    Constants_D(3);
    String description;
    int i;
 
    private Constants2(){ //定义默认构造方法 
    }
        //定义带参数的构造方法，参数类型为字符串型
        private Constants2(String description){
        this.description=description;
        private Constants2(int i){//定义带参数的构造方法，参数类型为整型
        this.i=this.i+i;
    }
}

        从枚举类型构造方法的语法中可以看出，无论是无参构造方法还是有参构造方法，修饰权限都为private。

    定义一个有参构造方法后，需要对枚举类型成员相应地使用该构造方法，如Constants_A(我是枚举成员A")和 Constants_D(3)语句，相应地使用了参数为 String 型和参数为 int 型的构造方法。然后可以在枚举类型中定义两个成员变量，在构造方法中为这两个成员变量赋值，这样就可以在枚举类型中定义该成员变量的getXXX()方法了。

package l11;

import static java.lang.System.out;

public class EnumConTest {
	enum Constants2 { // 将常量放置在枚举类型中
		Constants_A("我是枚举成员A"), // 定义带参数的枚举类型成员
		Constants_B("我是枚举成员B"),
		Constants_C("我是枚举成员C"),
		Constants_D(3);
		private String description;
		private int i = 4;

		private Constants2() {
		}

		// 定义参数为String型的构造方法
		private Constants2(String description) {
			this.description = description;
		}

		private Constants2(int i) { // 定义参数为int型的构造方法
			this.i = this.i + i;
		}

		public String getDescription() { // 获取description的值
			return description;
		}

		public int getI() { // 获取i的值
			return i;
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < Constants2.values().length; i++) {
			out.println(Constants2.values()[i] + "调用getDescription()方法为：" + Constants2.values()[i].getDescription());
		}
		out.println(Constants2.valueOf("Constants_D") + "调用getI()方法为：" + Constants2.valueOf("Constants_D").getI());
	}
}

运行结果 

  还可以将这个 getDescription()方法放置在接口中，使枚举类型实现该接口，然后使每个枚举类型实现接口中的方法。

package l11;

public interface EnumInterface {
	public String getDescription();
	public int getI();
}

 

package l11;

import static java.lang.System.out;
public enum AnyEnum implements EnumInterface {
	Constants_A { // 可以在枚举类型成员内部设置方法
		public String getDescription() {
			return ("我是枚举成员A");
		}

		public int getI() {
			return i;
		}
	},
	Constants_B {
		public String getDescription() {
			return ("我是枚举成员B");
		}

		public int getI() {
			return i;
		}
	},
	Constants_C {
		public String getDescription() {
			return ("我是枚举成员C");
		}

		public int getI() {
			return i;
		}
	},
	Constants_D {
		public String getDescription() {
			return ("我是枚举成员D");
		}

		public int getI() {
			return i;
		}
	};
	private static int i = 5;

	public static void main(String[] args) {
		for (int i = 0; i < AnyEnum.values().length; i++) {
			out.println(AnyEnum.values()[i] + "调用getDescription()方法为：" + AnyEnum.values()[i].getDescription());
			out.println(AnyEnum.values()[i] + "调用getI()方法为：" + AnyEnum.values()[i].getI());
		}
	}
}

运行结果 

11.1.3 使用枚举类型的优势

枚举类型声明提供了一种用户友好的变量定义方法，枚举了某种数据类型所有可能出现的值。总结枚举类型，它具有以下特点:、


（1）类型安全。
（2）紧凑有效的数据定义。
（3）可以和程序其他部分完美交互。
（4）运行效率高

11.2 泛型

11.2.1 回顾"向上转型"与"向下转型"

package l11;

	public class Test {
			private Object b; // 定义Object类型成员变量

			public Object getB() { // 设置相应的getXXX()方法
				return b;
			}

			public void setB(Object b) { // 设置相应的setXXX()方法
				this.b = b;
			}

			public static void main(String[] args) {
				Test t = new Test();
				t.setB(new Boolean(true)); // 向上转型操作
				System.out.println(t.getB());
				t.setB(new Float(12.3));
				Float f = (Float) (t.getB()); // 向下转型操作
				System.out.println(f);
			}
		}

运行结果 

 

11.2.2 定义泛型类

，Object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常使传入的值与返回的值都以Object类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来的类型，否则在运行时将会发生ClassCastException异常。        

在JDK1.5 版本以后，提出了泛型机制。其语法如下:

类名<T>

             其中，T代表一个类型的名称。

将上一个代码改为定义类时使用泛型的形式。

public class OverClass<T> { // 定义泛型类
	private T over; // 定义泛型成员变量
 
	public T getOver() { // 设置相应的getXXX()方法
		return over;
	}
 
	public void setOver(T over) { // 设置相应的setXXX()方法
		this.over = over;
	}
 
	public static void main(String[] args) {
		//实例化一个Boolean型的对象
		OverClass<Boolean> over1 = new OverClass<Boolean>();
		//实例化一个Float型的对象
		OverClass<Float> over2 = new OverClass<Float>();
		over1.setOver(true);
		over2.setOver(12.3f);
		Boolean b = over1.getOver();
		Float f = over2.getOver(); 
		System.out.println(b);
		System.out.println(f);
	}
}

运行结果

    使用泛型这种形式将不会发生ClassCastExce ption 异常，因为在编译器中就可以检查类型匹配是否正确。  

      例如，在项目中定义泛型类。

OverClass<Float> over2=new OverClass<F loat>(); over2.setover(12.3f); //Integer i=over2.getOver();//不能将F1 oat型的值赋予Integer变量 

11.2.3 泛型的常规用法

定义泛型类时声明多个类型

  在定义泛型类时，可以声明多个类型。语法如下:

MutiOverClass<T1,T2>
MutiOverClass:泛型类名称

其中，T1 和 T2 为可能被定义的类型。这样在实例化指定类型的对象时就可以指定多个类型。

MutiOverClass<Boolean,Float>=new Mutid OverClass<Boolean,Float>();

定义泛型类时声明数组类型

        定义泛型类时也可以声明数组类型，下面的实例中定义泛型时便声明了数组类型。

 

package l11;

public class ArrayClass<T> {
	private T[] array; // 定义泛型数组

	public void SetT(T[] array) { // 设置SetXXX()方法为成员数组赋值
		this.array = array;
	}

	public T[] getT() { // 获取成员数组
		return array;
	}

	public static void main(String[] args) {
		ArrayClass<String> a = new ArrayClass<String>();
		String[] array = { "成员1", "成员2", "成员3", "成员4", "成员5" };
		a.SetT(array); // 调用SetT()方法
		for (int i = 0; i < a.getT().length; i++) {
			System.out.println(a.getT()[i]); // 调用getT()方法返回数组中的值
		}
	}
}

运行结果

         此可见，可以在使用泛型机制时声明一个数组，但是不可以使用泛型来建立数组的实例。例如，下面的代码就是错误的：

public class ArrayClass <T>{  

  //private T[] array=newT[10]; //不能使用泛型来建立数组的实例    

...

}

 

集合类声明容器的元素

        实际应用中，通过在集合类中应用泛型可以使集合类中的元素类型保证唯一性，这样在运行时就不会产生ClassCastException异常，提高了代码的安全性和可维护性。可以使用K和V两个字符代表容器中的键值和与键值相对应的具体值。

package l11;

import java.util.HashMap;
import java.util.Map;

public class MutiOverClass<K, V> {
	public Map<K, V> m = new HashMap<K, V>(); // 定义一个集合HashMap实例
	// 设置put()方法，将对应的键值与键名存入集合对象中

	public void put(K k, V v) {
		m.put(k, v);
	}

	public V get(K k) { // 根据键名获取键值
		return m.get(k);
	}

	public static void main(String[] args) {
		// 实例化泛型类对象
		MutiOverClass<Integer, String> mu = new MutiOverClass<Integer, String>();
		for (int i = 0; i < 5; i++) {
			// 根据集合的长度循环将键名与具体值放入集合中
			mu.put(i, "我是集合成员" + i);
		}
		for (int i = 0; i < mu.m.size(); i++) {
			// 调用get()方法获取集合中的值
			System.out.println(mu.get(i));
		}
	}
}

运行结果         上面例子中泛型类 MutiOverClass 纯属多余,因为在 Java 中集合架已经被泛型化了，可以在主方法中直接使用public Map<K,V> m=new HashMap<K,V>0;语句创建实例，然后相应调用Map接口中的 put()与get()方法完成填充容器或根据键名获取集合中具体值的功能。         集合中除了HashMap 这种集合类型之外，还包括 ArrayList、Vector等。表11.2列举了几个常用的被泛型化的集合类。

常用的被泛型化的集合类
集合类泛型定义
ArrayListArrayList<E>
HashMapHashMap<K,V>
HashSetHashSet<E>
VectorVector<E>
package l11;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

public class ListClass {
	public static void main(String[] args) {
		// 定义ArrayList容器，设置容器内的值类型为Integer
		ArrayList<Integer> a = new ArrayList<Integer>();
		a.add(1); // 为容器添加新值
		for (int i = 0; i < a.size(); i++) {
			// 根据容器的长度循环显示容器内的值
			System.out.println("获取ArrayList容器的值：" + a.get(i));
		}
		// 定义HashMap容器，设置容器的键名与键值类型分别为Integer与String型
		Map<Integer, String> m = new HashMap<Integer, String>();
		for (int i = 0; i < 5; i++) {
			m.put(i, "成员" + i); // 为容器填充键名与键值
		}
		for (int i = 0; i < m.size(); i++) {
			// 根据键名获取键值
			System.out.println("获取Map容器的值" + m.get(i));
		}
		// 定义Vector容器，使容器中的内容为String型
		Vector<String> v = new Vector<String>();
		for (int i = 0; i < 5; i++) {
			v.addElement("成员" + i); // 为Vector容器添加内容
		}
		for (int i = 0; i < v.size(); i++) {
			// 显示容器中的内容
			System.out.println("获取Vector容器的值" + v.get(i));
		}
	}
}

 运行结果

11.2.4 泛型的高级用法

        泛型的高级用法主要包括通过类型参数T的继承和通过类型通配符的继承来限制泛型类型，另 外，开发人员还可以继承泛型类或者实现泛型接 口，本节将对泛型的一些高级用法进行讲解。

通过类型参数T的继承限制泛型类型

        默认可以使用任何类型来实例化一个泛型类对象，但Java中也对泛型类实例的类型作了限制，这主要通过对类型参数T实现继承来体现，语法如下:

class 类名称<T extends anyClass>

 

package l11;
import java.util.*;

public class LimitClass<T extends List> { // 限制泛型的类型
 
	public static void main(String[] args) {
		
		// 可以实例化已经实现List接口的类
		LimitClass<ArrayList> l1 = new LimitClass<ArrayList>();
		LimitClass<LinkedList> l2 = new LimitClass<LinkedList>();
		// 这句是错误的，因为HashMap没有实现List()接口
		LimitClass<HashMap> l3 = new LimitClass<HashMap>();
	}
}

通过类型通配符的继承限制泛型类型

          在泛型机制中，提供了类型通配符，其主要作用是在创建一个泛型类对象时，限制这个泛型类的类型，或者限制这个泛型类型必须继承某个接口或某个类(或其子类)。要声明这样一个对象可以使用“?”通配符，同时使用 extends 关键字来对泛型加以限制。

注：

        通过对类型参数T 过对类型通配符实现继承限制泛型类型时，则在实例化时才进行限制。

使用泛型类型通配符的语法如下:

泛型类名称<? extends list> a=null;

        其中，<? extends List>表示类型未知，当需要使用该泛型对象时，可以单独实例化。 例如，在项目中创建一个类文件，在该类中限制泛型类型。 

A<? extends list> a=null;:
a=new A<ArrayList>();
a=new A<LinkedList>();

package l11;

import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;

public class WildClass {
	public static void main(String[] args) {
		List<String> l1 = new ArrayList<String>(); // 创建一个ArrayList对象
		l1.add("成员"); // 在集合中添加内容
		List<?> l2 = l1; // 使用通配符
		List<?> l3 = new LinkedList<Integer>();
		System.out.println("l1:" + l1.get(0)); // 获取l1集合中第一个值
		System.out.println("l2:" + l2.get(0)); // 获取l2集合中第一个值
		l1.set(0, "成员改变"); // 没有使用通配符的对象调用set()方法
		// l2.set(0, "成员改变"); // 使用通配符的对象调用set()方法，不能被调用
		// l3.set(0, 1);
		System.out.println("l1:" + l1.get(0)); // 可以使用l1的实例获取集合中的值
		System.out.println("l2:" + l2.get(0)); // 可以使用l2的实例获取集合中的值
	}
}

 运行结果

 

继承泛型类与实现泛型接口

        定义为泛型的类和接口也可以被继承与实现。

        在项目中创建一个类文件，在该类中继承泛型类。

public class Extendclass<ti> {
}
Class SubClass<Tl,T2,T3> extends ExtendClass<T1>{// 泛型可以比父类多，但不可以比父类少
}

         如果在 SubClass 类继承 ExtendClass类时保留父类的泛型类型，需要在继承时指明，如果没有指明，直接使用 extends ExtendsClass 语句进行继承操作，则 SubClass类中的T1、T2和T3都会自动变为Object，所以在一般情况下都将父类的泛型类型保留。        

        定义的泛型接口也可以被实现。

        在项目中创建一个类文件，在该类中实现泛型接口。

interface TestInterface<Tl> {
}
class SubClass2<T1, T2, T3> implements TestInterface<Ti> {
}

 

11.2.5 泛型总结 

使用泛型需遵循以下原则。

(1)泛型的类型参数只能是类类型，不可以是简单类型，如A<int>这种泛型定义就是错误的。

(2)泛型的类型个数可以是多个。
(3)可以使用extends关键字限制泛型的类类型。

(4)可以使用通配符限制泛型的类型。

11.3 小结

讲解了枚举类型以及泛型的用法。枚举类型与泛型为JDK1.5版本新增的内容。

秦小小是boos
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PD3.0详解 第十二章总结
大师匈的博客
11-04 3526
前面的章节分开介绍了协议层和策略层的俩个重要策略！今天想总结一下，并做一些补充。如果有一些内容没有介绍到，可能后续会补充，同学们可以关注一下大师匈。 补充点一、读Emark 大家都知道PD是标定了100W的功率，也就是20V5A的最大电压电流。那么普通的线走5A电流是不合电气标准的，那么就需要一跟Emark线。圈里人都知道的哈。。。前面讲到的Vconn就是给这个线供电的。 一般是上电识别到这个线就会用 SOP‘ 类型的数据去读他的一些具体信息，识别它就是靠CC线的Ra（0.8K~1KΩ），这个Ra电阻是这个
C语言-返回数组并输出其值
qq_40286155的博客
04-03 2900
先看如下程序： #include<stdio.h> #define M 2 #define N 3 int main() { float* average_stu(float score[][3]);//函数声明 float score[M][N]={{89,99,80},{100,88,90}}, *aver_stu; int i; //每个学生平均成绩 aver_stu=a...
高一计算机知识点第一章,第一章计算机基础知识知识点总结
weixin_35638013的博客
06-15 1917
第一章计算机基础知识1、 信息递、处理、开发和利用信息资源的相关技术。2、 数据，是指存储在某种媒体上可以加以鉴别的符号资料。这里的符号包括文字、字母、数字、图形、音像、音频与视频等多媒体数据。数据是信息的具体表现形式，是信息的载体，而信息是对数据进行加工得到的结果。3、 文化的核心部分4、 文化具有的基本属性：5、 计算机文化：以计算机为核心，集网络文化、信息文化、多媒体文化于一体，并对社会生活...
计算机网络_第四章知识总结
qq_42148307的博客
12-26 3939
文章目录网络层提供的两种服务网际协议 IP虚拟互连网络分类的 IP 地址IP 地址与硬件地址地址解析协议 ARPIP 数据报的格式IP 层转发分组的流程划分子网和构造超网划分子网和构造超网使用子网时分组的转发无分类编址 CIDR网际控制报文协议 ICMP互连网的路由选择协议内部网关协议 RIP内部网关协议 OSPF外部网关协议 BGPIPv6IP 多播网络地址转换 NAT 网络层提供的两种服务 在两个终端设备的逻辑或物理端口之间，通过建立的双向的透明传输通道。虚电路表示这只是一条逻辑上的连接，分组都沿着这
第十一章练习总结
qq_36741436的博客
11-21 372
第十一章练习
算法导论第十二章总结以及课后题答案
wk_bjut_edu_cn的博客
03-07 3573
二叉搜索树 总结 查找二叉搜索树中最大关键字元素 TREE-MAXIMUM(x) while x.right!=NIL x=x.right return x 查找二叉搜索树中最小关键字元素 TREE-MINIMUM(x) while x.left!=NIL x=x.left return x 插入一个结点到二叉树 TREE-INSERT(T,z
c语言第七章函数实验总结,第六章 实验报告 (函数与宏定义)
weixin_39588084的博客
05-20 2722
c语言实验报告实验项目:1、编写由三角形三边求面积的函数2、编写求N的阶层3、求两个整数的最大公约数4、打印输出的指定图形5、模块化程序设计姓名：张顺利实验地点：第一教学楼514教室实验时间：4月30日一、实验目的与要求1.编写由三角形三边求面积的函数调用area()函数求三角形的面积；在求面积函数中运用海伦公式；2.编写求N的阶层定义符号常量；使用长整型变量存放累乘积；在函数中，使用局部...
数据库系统概念总结：第十四章 事务
qq_39739850的博客
09-15 1764
第十四章 事务 14.1 事务概念 事务是访问并可能更新各种数据项的一个程序执行单元 ACID特性 –原子性（Atomicity）：事务的所有操作都在数据库中正确反映，或者没有 –一致性（Consistency）：隔离执行事务可保持数据库的一致性 –隔离性（Isolation）：虽然可以同时执行多个事务，但每个事务必须不知道其他并发执行的事务：必须从其他并发执行的事务中隐藏中间事务结果。也就是说...
数据库系统概念总结：第十一章 索引与散列
qq_39739850的博客
09-15 1823
第十一章 索引与散列 11.1 基本概念 基本的索引类型 –顺序索引：基于值的顺序排序 –散列索引：基于将值平均分布到若干散列同中。一个值所属的散列桶是由一个函数决定的，该函数称为散列函数 评价顺序索引和散列的因素 –访问类型（access type）： –访问时间（access time） –插入时间（insertion time） –删除时间（deletion time） –空间开销（spa...
C++ Primer学习总结 第11章 关联容器
code
03-09 1246
第11章 关联容器 1.    使用map的简单例子: 运行结果为:   2.    初始化map和set:   3.    set与multiset的区别:   4.    使用map和set时,其元素类型必须是定义了严格弱序的(即定义了号比较的),如果元素类型没有定义   5.    pair类型:pair是一个用来生成特定类型的模板. pa
第11章制造系统的工艺自动化.ppt
11-12
"第11章制造系统的工艺自动化" manufacturing system的工艺自动化是指在manufacturing system中应用自动化技术来提高生产效率和产品质量。该技术可以应用于生产过程中的各个环节，包括设计、制造、装配和检测。 ...
第一章操作系统概述PPT文档.pptx
11-14
用户告诉操作系统执行hello程序，操作系统找到该程序，检查其类型，检查程序首部，找出正文和数据的地址，文件系统找到第一个磁盘块，父进程需要创建一个新的子进程，执行hello程序，操作系统需要将执行文件映射到...
第11章+知识总结和解题指导1
08-03
第八 章 并 发 控 制事务处理技术主要包括数据库恢复技术和并发控制技术。本章讨论数据库并发控制的基本概念和实现技术。本章内容有一定的深度和难度。读者学习本章一
沪科版八年级数学上第十一章知识总结.pdf
10-23
沪科版八年级数学上第十一章知识总结.pdf
九年级化学第十一章知识点总结.doc
10-11
九年级化学第十一章知识点总结.doc
为什么选择Python作为AI开发语言
AI心易行者
06-09 1770
综上所述，Python因其简洁易读的语法、丰富的库和框架、广泛的社区支持、适合快速原型开发的特性以及良好的兼容性和集成性，成为AI开发的首选语言。而像PlugLink这样的工具，则进一步提升了Python在AI开发中的效率和便利性。对于任何希望在AI领域有所作为的开发者来说，掌握Python无疑是必不可少的技能。在未来，随着AI技术的不断发展和进步，Python必将继续扮演重要角色，推动这一领域的创新和变革。如果你还没有开始学习Python，那么现在就是最好的时机。
简单的项目部署脚本（转载）
u010230019的博客
06-09 668
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
最新发布
m0_74100417的博客
06-09 1481
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 487
修改菜品——后端Java
pmbok第七版有多少章
07-20
PMBOK第七版共有12章。这些章节包括：引言、项目管理基本原则、项目管理环境、项目管理过程、项目管理道德与责任、整合管理、范围管理、进度管理、成本管理、质量管理、资源管理和沟通管理。每个章节都涵盖了不同的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值