JAVA类成员
static 关键字修饰的成员就是类成员，前面已经介绍的类成员有类属性、类方法、静态初始化块等三个成分，static关键字不能修饰构造器。static修饰的类成员属于整个类，不是属于单个实例的。
在JA V A类里只能包含属性，方法，构造器，初始化块，内部类和枚举类等六种成员，也包含了接口，目前已经介绍了前面四种，其中static可以修饰属性，方法，初始化块，内部类和枚举类，以static修饰的成员就是类成员，类成员属于整个类，而不是属于单个对象。
我们要知道，当系统第一次准备使用该类时，系统会为该类属性分配内存空间，类属性开始生效，直到该类被卸载，该类的类属性怕占有的内存才被系统的垃圾回收机制回收。类属性生存范围几乎等同于该类的生存范围，当类初始化完成后，类属性也被初始化完成。
类属性既可通过类来访问，也可通过类的对象来访问。但通过类的对象来访问类属性时，实际上并不是访问该对象所具有的属性。当通过对象来访问类属性时，系统会在底层转换让为通过该类来访问类属性。
由于所有对象实际上并不保持类属性，类属性是由该类来保持的，同一个类的所有对象访问类属性时，实际上访问的是该类所持有的属性。因此从程序运行表面上来看，即可看到同一类的所有实例的类属性共享同一块内存区。
类方法也是类成员的一种，类方法也是属于类的，通常直接使用类作为调用类方法，但也可以使用对象来调用类方法。与类属性类似的，即使使用对象来调用类方法，其效果与采用类来调用类方法完全一样。
当使用实例来访问类成员时，实际依然委托给该类来访问类成员，因此即使某个实例为Null它也可以访问它所属类的类成员。
本来是不想写太多的概念性的东西的，但为了大家能更好的理解写出来的代码，所以还是麻烦下自已写出来。
看代码：
public class NullAccessStatic
{
private static void test()
{
System.out.println("static修饰的类方法");
}
//主方法入口
public static void main(String[] args)
{
//定义一个NullAccessStatic变量，其值为：null
NullAccessStatic nas = null;
//null对象调用所属类的静态方法
nas.test();
}
}
编译结果：
从编译结果来看，一切正常，这表明null对象可以访问它所属类的类成员
如果一个null对象访问实例成员（属性和方法），将会引发NullPointerException异常，因为null表明该实例根本不存在，既然实例不存在，理所当然的，那么它的属性和方法也不存在。
静态初始化块也是类成员的一种，静态初始化块用于执行类初始化动作，在类的初始化阶段，系统会调用该类的静态初始化块来对类进行初始化。一旦该类初始化结束后，静态初始化块将永远不会获得执行的机会。
对于static 关键字而言，有一条非常重要的规则：类成员（包括方法，初始化块，内部类和枚举类）不能访问实例成员（包括属性，方法，初始化块，内部类和枚举类）。因为类成员是属于类的，类成员的作用域比实例成员的作用域更大。完全可能出现类成员已经初始化完成，但实例成员还不曾初始化，如果允许类成员访问实例成员将会引起大量错误。
单例（Singleton）类
大部分时候，我们把类的构造器定义成public访问权限，允许任何类自由创建该类的对象。但在某此时候，允许其他类自由创建该类的对象没有任何意义，还可能造成系统性能下降（因为创建一个对象的系统开销问题）。例如系统可能只有一个窗口管理器，一个假脱机打印设备或一个数据库引擎访问点，此时如果在系统中为这些类创建多个对象就没有太大的实际意义。
如果一个类始终只能创建一个实例，则这个类被称为单例类。
总之，在一些特殊场景下，要求不允许自由创建该类的对象，而是只允许为该类创建一个对象，为了避免其他类自由创建该类的实例，我们把该类的构造器使用private修饰，从而把该类的所有构造器隐藏起来。
根据良好封装的原则：一旦把该类的构造器隐藏起来，则需要提供一个public方法作为该类的访问点，用于创建该类的对象，且该方法必须使用static修饰（因为调用该方法之前还不存在对象，因此调用该方法的不可能是对象，只能是类）。
除此之外，该类还必须缓存已经创建的对象，否则该类无法知道是否曾经创建过对象，也就无法保证只创建一个对象。为此该类需要使用一个属性来保存曾经创建的对象，因为该属性需要被上面的静态方法访问，故该属性必须使用static修饰。
看代码：
class Singleton
{
//使用一个变量来缓存曾经创建的实例
private static Singleton instance;
//将构造器使用private 修饰，隐藏该构造器
private Singleton()
{
}
//提供一个静态方法，用于返回Singleton实例
//该方法可以加入自定义的控制，保证只产生一个Singleton对象
public static Singleton getInstance()
{
//如果instance为null，表明还不曾经创建Singleton对象
//如果instance不为null,则表明已经创建了Singleton对象，将不会执行该方法
if(instance == null)
{
//创建一个Singleton对象，并将其缓存起来
instance = new Singleton();
}
return instance;
}
}
public class TestSingleton
{
public static void main(String[] args)
{
//创建Singleton对象不能通过构造器，只能通过getInstance方法
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
//将输出true
System.out.println(s1== s2);
}
}
看下编译结果：
正是通过上面getInstance 方法提供的自定义控制（这也是封装的优势：不允许自由访问类的属性和实现细节，而是通过方法来控制合适暴露），保证Singleton类只能产生一个实例，所以在TestSingleton类的main方法中看到两冷饮产生的Singleton对象实际上是同一个对象。
可以看出单例模式有以下特点：
》单例类只可有一个实例。
》单例类必须自己创建自己这惟一的实例
》单例类必须给所有其他对象提供这一实例
单例模式的特点主要表现在单例类如何将自己袖珍化上。
饿汉式单例类
饿汉式单例类是在JA V A语言里实现得最为简便的单例类。
public class EagerSingleton
{
private static final EagerSingleton m_instance = new EagerSingleton();
//定义私有构造器
private EagerSingleton()
{
}
//主方法入口
public static EagerSingleton getInstacnce()
{
return m_instance
}
}
这时我们知道使用单例模式有一个很重要的必要条件：
在一个系统要求一个类只有一个实例时才应当使用单例模式。反过来说，如果一个类可以有几个实例共存，那么就没有必要使用单例类。
java内部类练习题
内部类练习题 一、按要求填空 1.请在以下代码的基础上完成下面几个小题 （1）在①和②的位置标注出内部类和外部类 （2）在③的位置定义一个count变量用来存放Circle实例的个数，并在④的位置编写语句用来统计Circle实例的个数。 （3）在⑤和⑥处根据注释语句填写代码 （4）在main()⑦的位置上编写语句调用Draw类中的drawSahpe()。 （5）将修改后的完整代码拷贝在下方： class Circle { //① private double radius = 0; ③ public Circle(double radius) { this.radius = radius; ④ } class Draw { //② public void drawSahpe() { ⑤ //输出radius变量的值 ⑥ //输出count变量的值 } } } public class OuterInnerClass { public static void main(String[] args) { ⑦ //编写语句调用Draw类中的drawSahpe() } } 答案： class Circle { //①外部类 private double radius = 0; static int count=0; public Circle(double radius) { this.radius = radius; count++; } class Draw { //②内部类
public void drawSahpe() { System.out.println(radius); System.out.println(count); } } } public class OuterInnerClass { public static void main(String[] args) { Circle objCircle=new Circle(10); Circle.Draw objDraw=objCircle.new Draw(); objDraw.drawSahpe(); } } 2.程序填空，使程序运行结果为 30 20 10 public class Demo{ public static void main (String[] args) { Outer.Inner obj=new Outer().new Inner(); obj.show(); } } class Outer{ public int number=10; class Inner{ public int number=20; public void show() { int number=30; System.out.print( ); System.out.print( ); System.out.print( ); } } } 答案： public class Demo{ public static void main (String[] args) { Outer.Inner obj=new Outer().new Inner(); obj.show();
javamath类常用方法
例如求平方根的(n)，求a的b次方(a, b)，求绝对值(n)等很多。下面是一些演示。publicclassMathTest { publicstaticvoidmain(String[]args) { intn=16; ？ 3)); ？ ？ } } publicclassMathDemo{ publicstaticvoidmain(Stringargs[]){ /** *abs求绝对值 */ 的时候会取偶数 */ // // // // // // // // // // /** *round四舍五入，float时返回int值，double时返回long值 */ //10 //11 //11 //11 //-10 //-11 //-11 //-10 } }
函数（方法） 描述 IEEEremainder(double,double) 按照IEEE754标准的规定，对两个参数进行余数运算。 abs(inta) 返回int值的绝对值 abs(longa) 返回long值的绝对值 abs(floata) 返回float值的绝对值 abs(doublea) 返回double值的绝对值 acos(doublea) 返回角的反余弦，范围在到pi之间 asin(doublea) 返回角的反正弦，范围在-pi/2到pi/2之间 atan(doublea) 返回角的反正切，范围在-pi/2到pi/2之间 atan2(doublea,doubleb) 将矩形坐标(x,y)转换成极坐标(r,theta) ceil(doublea) 返回最小的（最接近负无穷大）double值，该值大于或等于参数，并且等于某个整数cos(double) 返回角的三角余弦 exp(doublea) 返回欧拉数e的double次幂的值 floor(doublea) 返回最大的（最接近正无穷大）double值，该值小于或等于参数，并且等于某个整数log(doublea) 返回（底数是e）double值的自然对数 max(inta,intb) 返回两个int值中较大的一个 max(longa,longb) 返回两个long值中较大的一个 max(floata,floatb) 返回两个float值中较大的一个 max(doublea,doubleb) 返回两个double值中较大的一个 min(inta,intb) 返回两个int值中较小的一个 min(longa,longb) 返回两个long值中较小的一个 min(floata,floatb)
C++程序设计复习题及参考答案
《C++程序设计》课程复习资料 一、单项选择题： 1.下列字符串中可以用作C++标识符的是[ ] －ld 2.定义变量int a=6，则a++的值是[ ] .6 C 3.已知字母A的ASCII码为65，则表示字符常量A 错误的是[ ] A. '\101' B. '\x41' C. 65 D.“A” 4.结构化程序由三种基本结构组成，不包括[ ] A.顺序结构 B.选择结构 C.控制结构 D.循环结构 5.己知有定义： const int D 5; int i=1; double f=; char c=15; 则下列选项错误的是[ ] A.++i; B. D--; C. c++; D. --f; 6.若有定义为“int *r =new int [10];”，则释放指针所指内存空间的操作是[ ] A. delete [ ]r; B. delete *r C. delete r; D. delete r[ ]; 7.下列哪个是C++语言的不正确的标识符[ ] B. Ab1 C. bgc D. int 8.下列哪个是C++语言的合法的字符常量[ ] A. ”\0” B. '054' C. '\x89' D. '\092' 9.定义整型变量x,y,z并赋初始值6的正确语句是[ ] A. int x=y=z=6; B. int x=6,y=6,z=6; C. x=y=z=6; D. int x,y,z=6; 10.用C++语言编写的代码程序[ ] A.可立即执行 B.是一个源程序 C.经过编译即可执行 D.经过解释才能执行 11.将两个字符串连接起来组成一个字符串时，选用的函数是[ ] A. strlen () B. strcpy () C. strcat () D. strcmp () 12.在程序中，预处理命令开头的字符都是[ ] A. * B. # C. & D. @ 13.在C++语言中，表示一条语句结束的符号是[ ] A. “#” B. “;” C. “}” D. “下面的循环语句中循环体执行的次数为 [ ] for(int i=0; i
JAVA中常用类的常用方法
JAVA中常用类的常用方法 一、类 1、clone()方法 创建并返回此对象的一个副本。要进行“ 克隆” 的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法 功能：比较引用类型数据的等价性。 等价标准：引用类型比较引用，基本类型比较值。 存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内 容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法 返回该对象的哈希码值。 5、notify()方法 唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法 唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比 较，不考虑大小写。 indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar)
匿名内部类
中的匿名内部类总结 匿名内部类也就是没有名字的内部类 正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写 但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口 实例1:不使用匿名内部类来实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat something"); } } public class Demo { public static void main(String[] args) { Person p = new Child(); p.eat(); } } 运行结果：eat something 可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person 类的引用 但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？ 这个时候就引入了匿名内部类 实例2：匿名内部类的基本实现 abstract class Person { public abstract void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println("eat something"); } }; p.eat(); } } 运行结果：eat something 可以看到，我们直接将抽象类Person中的方法在大括号中实现了 这样便可以省略一个类的书写
Java常用类
常用类 （1）字符串相关类（String，StringBuffer） 1）https://www.wendangku.net/doc/0a16340839.html,ng.String类代表不可变得字符序列； 2）"***"为该类的一个对象； 3）String类的常见构造方法：String（String original）//创建一个String对象为original 的拷贝；String（char[] value）//用一个字符数组创建一个String对象；String（char[] value,int offset,int count）； 4）String 类的常用方法：char charAt（int index）//返回第index个字符、int length()//返回字符串的长度、int indexOf(String str)//返回字符串中出现Str的第一个位置；int indexOf(String str,int fromIndex)//返回字符串中从fromindex开始出现Str的第一个位置；boolean equalsIgnoreCase(string another)//比较是否相等，忽略大小写；String replace(char olochar,char newchar)；boolean startswith(String prefix)//判断字符串是否以prefix字符串开头；boolean endsWith(String suffix);String toUpperCase()//返回一个字符串为该字符串的大写形式；String toLowerCase();String substring(int beginIndex0)//返回该字符串从beginindex开始到结尾的子字符串；String substring(int beginindex,int endindxt);String trim()//返回将该字符串去掉开头和结尾空格后的字符串。静态重载方法：public static String valueOf（。。。）//将基本类型数据转换为字符串。String[] split(String regex)//将一个字符串按照指定的分隔符分隔，返回分隔后的字符串数组。 （2）StringBuffer类:可变的字符串序列； 1）构造方法：StringBuffer();StringBuffer(string str); 2）常用方法：StringBuffer append()；insert();delete();indexOf();rerverse(); （2）基本数据类型包装类:Integer,Double将基本数据类型包装成一个对象； （2）Math类：方法 （3）File类：各类的方法 （4）枚举类Enum：只能够取特定值中的一个，使用enum关键字，是https://www.wendangku.net/doc/0a16340839.html,ng.Enum类型；
[科普]C执行顺序
C# 类的初始化顺序 继承类的static数据成员的初始化器, 继承类的static构造器 (在类名, 第一次被引用时, 调用, 如果, 没有这个构造器, 则static数据成员何时被初始化, 是不可预测的) 继承类的实例型数据成员的初始化器 在执行继承类的构造器的内容之前; 基类的static数据成员的初始化器即 static int a = 1; /// 类数据成员的定义 基类的static 构造器 ,(如果,基类的类名, 先于继承类被引用, 则先执行基类的static构造器) 基类的实例型数据成员的初始化器 基类的构造器 接着执行继承类的构造器的内容; Example : public class Base { A: private static int Number = 12; B: private int localNumner = 1; C: static Base() { /// } D: public Base() { } }
public class Child : Base { E: private static int ChildNumber = 14; F: private int local_child_number = 7; G: static Child() { /// } H: public Child() { I: /// } } Child child = new Child(); 初始化顺序为 E G F H A C B D I; static构造器的调用时刻是, 第一次引用该类的类名; public class Test { static Test() { } public staitc int Account { get { return 1; } } /// 只是举例 public static int GetAccount() { return 1;
JAVA中常用类的常用方法
JAVA屮常用类的常用方法 一．java?丨ang.Object 类 1、clone()方法 创建丼返M此对象的一个副木。要进行“克隆”的对象所属的类必须实现https://www.wendangku.net/doc/0a16340839.html,ng. Cloneable 接口。 2、equals(Objectobj)方法 0 功能：比较引用类型数据的等价性。 0 等价标准.?引用类型比较引用，基木类型比较值。 0 存在特例.?对File、String、Date及封装类等类型来说，是比较类型及对象的内稃而+ 考虑引用的是否为同一实例。 3、finalize〇方法 当垃圾丨"丨收器确定>(、存在对该对象的更多引用时，由对象的垃圾丨"丨收器调用此方法。 4、hashCode〇方法返 回该对象的哈希码值。 5、notify〇方法 唤醒在此对象监视器上等待的中?个线祝。 6、notifyAII〇方法 唤醒在此对象监视器上等待的所有线程= 7、toString()方法 返W该对象的字符串表示。在进行String与其它类型数据的连接操作时，&动调用tostringo 方法。可以根据耑要重写toStringO方法。 8、wait()方法 在其他线程调用此对象的n〇tify()方法或notifyAIIO方法前，异致当前线程等待。 二、字符串相关类 I String 类 charAt(int index)返回指定索引处的char值。compareTo{String anotherString)按字
典顺序比较两个字符串。compareTolgnoreCase(Stringstr)按字典顺序比较两个字 符串，不考虑人小写。concat(String str)将指定字符串连接到此字符串的结尾。 endsWith(String suffix)测试此字符串是否以指定的〗?缀结束。equals{Object anObject)将此字符串与指定的对象比较。 equalslgnoreCase(String anotherString)将此String 与另一个String 比较，考虑人小'与’。indexOf(int ch)返H指定字符在此字符串屮第一次出现处的索引。 indexOf(String str)返回第一次出现的指定子字符串在此字符串屮的索引， lastlndexOf(intch)返回指定字符在此字符串中最后??次出现处的索引。 length()返|n丨此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 split(String regex)根据给定正则表达式的匹配拆分此字符串。startsWith{String prefix)测试此字符 串是否以指定的前缀开始。substring(int beginlndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginlndex, int endlndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginlndex 处开始，一直到索引endlndex-1处的字符。 t〇CharArray()将此字符串转换为一个新的字符数组。
JAVA内部类的作用、方法、使用
引用：JAVA内部类的作用、方法、使用 今天，因为在程序中使用内部类[事件]，但要将外部类传递到调用类里面。 在内部类如何调用外部类，通过网络搜索，找到了方法： outclass.this，可以在内部类里引用外部类对象。 当然，还有其他的一些设计与说明，非常的好！ 内部类:一个内部类的定义是定义在另一个内部的类。 原因是: 1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。 2.对于同一个包中的其他类来说，内部类能够隐藏起来。 3.匿名内部类可以很方便的定义回调。 4.使用内部类可以非常方便的编写事件驱动程序。 提起Java内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显著，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍： * 第一次见面 public interface Contents { int value(); } public interface Destination { String readLabel(); } public class Goods { private class Content implements Contents { private int i = 11; public int value() { return i; } } protected class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; }
C类构造函数初始化列表
类构造函数初始化列表 初始化列表地定义在使用编程地过程当中，常常需要对类成员进行初始化，通常地方法有两种：一种是构造函数内对类地成员赋值，一种则是使用初始化列表地构造函数显式地初始化类地成员. 构造函数初始化列表以一个冒号开始，接着是以逗号分隔地数据成员列表，每个数据成员后面跟一个放在括号中地初始化式.例如：{ : ; ; 构造函数初始化列表(): ()() {} 构造函数内部赋值() { ; ; } }; 从技术上说，用初始化列表来初始化类成员比较好，但是在大多数情况下，两者实际上没有什么区别.第二种语法被称为成员初始化列表，之所以要使用这种语法有两个原因：一个原因是必须这么做，另一个原因是出于效率考虑初始化列表地必要性初始化和赋值对内置类型地成员没有什么大地区别，像上面地任一个构造函数都可以.但在一些情况下，初始化列表可以做到构造函数做不到地事情： 、类里面有类型地成员，它是不能被赋值地，所以需要在初始化列表里面初始化它； 、引用类型地成员（也就是名字成员，它作为一个现有名字地别名），也是需要在初始化列表里面初始化地，目地是为了生成了一个其名字成员在类外可以被修改而在内部是只读地对象；
、需要调用基类地构造函数，且此基类构造函数是有参数地； 、类里面有其他类类型地成员，且这个“其他类”地构造函数是有参数地. 举个例子：设想你有一个类成员，它本身是一个类或者结构，而且只有一个带一个参数地构造函数. { : ( ) { ... } }; 因为有一个显式声明地构造函数，编译器不产生一个缺省构造函数（不带参数），所以没有一个整数就无法创建地一个实例. * ; 出错!! * (); 如果是另一个类地成员，你怎样初始化它呢？答案是你必须使用成员初始化列表. { ; : (); }; 必须使用初始化列表来初始化成员 () : () {……} 没有其它办法将参数传递给. 情况和其实一样地道理.如果成员是一个常量对象或者引用也是一样.根据地规则，常量对象和引用不能被赋值，它们只能被初始化. 初始化列表与构造函数赋值地效率比较首先把数据成员按类型分类并分情况说明: .内置数据类型，复合类型（指针，引用） 在成员初始化列表和构造函数体内进行，两者在性能和结果上都是一样地 .用户定义类型（类类型） 两者在结果上相同，但是性能上存在很大地差别. 因为编译器总是确保所有成员对象在构造函数体执行之前初始化，所以对于用户自定义类型（类），在初始化列表中只会调用类地构造函数，在构造函数体中赋值就会先调用一次类地构造函数，然后再调用一次类地赋值操作符函数. 显然后者在性能上有所损失，特别对于构造函数和赋值操作符都需要分配内存空间地情况，使用初始化列表，就可以避免不必要地多次内存分配. 举个例子：假定你有一个类具有一个类型地成员，你想把它初始化为" .".你有两种选择： 、使用构造函数赋值()
数据结构实验
实验1：顺序表基本操作 一、实验目的 1.学会定义线性表的顺序存储类型，实现C程序的基本结构，对线性表 的一些基本操作和具体的函数定义。 2.掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集 等运算。 3.掌握对多函数程序的输入、编辑、调试和运行过程。 二、实验要求 1．预习C语言中结构体的定义与基本操作方法。 2．对顺序表的每个基本操作用单独的函数实现。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。 三、实验内容： 1．编写程序实现顺序表的下列基本操作： (1)初始化顺序表La。 (2)将La置为空表。 (3)销毁La。 (4)在La中插入一个新的元素。 (5)删除La中的某一元素。 (6)在La中查找某元素，若找到，则返回它在La中第一次出现的位置， 否则返回0。 (7)打印输出La中的元素值。 2．编写程序完成下面的操作： (1)构造两个顺序线性表La和Lb，其元素都按值非递减顺序排列。 (2)实现归并La和Lb得到新的顺序表Lc，Lc的元素也按值非递减顺序排列。 (3)假设两个顺序线性表La和Lb分别表示两个集合A和B，利用 union_Sq操作实现A=A∪B。 四、思考与提高 假设两个顺序线性表La和Lb分别表示两个集合A和B，如何实现A=A ∩B ？ 实验2：单链表基本操作 一、实验目的 1.学会定义单链表的结点类型，实现对单链表的一些基本操作和具体 的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。 2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。 二、实验要求
1．预习C语言中结构体的定义与基本操作方法。 2．对单链表的每个基本操作用单独的函数实现。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。 三、实验内容 1．编写程序完成单链表的下列基本操作： (1)初始化单链表La。 (2)在La中第i个元素之前插入一个新结点。 (3)删除La中的第i个元素结点。 (4)在La中查找某结点并返回其位置。 (5)打印输出La中的结点元素值。 2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、 Lb合并成一个有序单链表Lc。 合并思想是：程序需要3个指针：pa、pb、pc，其中pa，pb分别指向La表与Lb表中当前待比较插入的结点，pc 指向Lc表中当前最后一个结点。依次扫描La和Lb中的元素，比较当前元素的值，将较小者链接到*pc 之后，如此重复直到La或Lb结束为止，再将另一个链表余下的内容链接到pc所指的结点之后。 3．构造一个单链表L，其头结点指针为head，编写程序实现将L逆置。 （即最后一个结点变成第一个结点，原来倒数第二个结点变成第二个结点，如此等等。） 四、思考与提高 1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？ 2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？ 实验3:循环队列基本操作 一、实验目的 1．熟悉并能实现循环队列的定义和基本操作。 2．了解用队列解决实际应用问题。 二、实验要求 1．进行队列的基本操作时要注意队列“先进先出”的特性。 2．复习关于队列操作的基础知识。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。 三、实验内容 1．任意输入队列长度和队列中的元素值，构造一个顺序循环队列，对其进行清空、插入新元素、返回队头元素以及删除队头元素操作。
关于JAVA内部类的说明与使用
关于JAVA内部类的说明与使用 1.关于内部类的说明 1）在一个类中定义另外一个类，这个类就叫做内部类(inner class) 。内部类的定义和普通类的定义没什么区别，它可以直接访问和引用它的外部类的所有变量和方法（包括private），就像外部类中的其他非static成员的功能一样。区别是，外部类只能声明为public和default，而内部类可以声明为private 和protected。 2）当我们建立一个inner class时，其对象就拥有了与外部类对象之间的一种关系，这是通过一个特殊的this reference形成的，当内部类的成员方法中访问某个变量/方法时，如果在该方法和内部类中都没有定义过这个变量，调用就会被传递给内部类中保存的那个外部类对象的引用（OuterClass.this），通过那个外部类对象的引用去调用这个变量。 2．内部类变量访问 2.1在main中直接从外部类调用内部类的方法 class Outer { private int index = 100; class Inner { private int index = 50; void print() { int index = 30; System.out.println(index); // 30 System.out.println(this.index); // 50 System.out.println(Outer.this.index); // 100 } } void print() { Inner inner = new Inner();//得到内部类的引用 inner.print(); } } class Test { public static void main(String[] args) {
java题
二、编写程序题 1、按以下要求编写程序 (1) 创建一个Rectangle类，添加width和height两个成员变量 (2) 在Rectangle中添加两种方法分别计算矩形的周长和面积 (3) 编程利用Rectangle输出一个矩形的周长和面积 public class Rectangle{ double width; double length; public Rectangle(){ this.width=width; this.length=length; } public double zhouzhang(){ return (width+length)*2; } public double mianji(){ return width*length; } public static void main(String[] args){ Rectangle R=new Rectangle(); System.out.println("周长为:"+R.zhouzhang()); System.out.println("面积为:"+R.mianji()); } } 运行结果： 周长为:0.0 面积为:0.0 2、按以下要求编写程序 (1) 编写Animal接口，接口中声明run() 方法 (2) 定义Bird类和Fish类实现Animal接口 (3) 编写Bird类和Fish类的测试程序，并调用其中的run()方法 3、设计类A和A的派生类B，要求： 1）A有两个数据成员a和b（都为int型）；B中继承了A中的a和b，又定义了自己的数据成员c（int型）。 2）为A添加含有两个参数的构造方法，对a和b初始化。 3）为B添加含有一个参数的构造方法，对c初始化。 4）完成主控方法，在主控方法中用B e1=new B 5)创建对象，把a、b、c分别初始化成3、4、5，最后输出它们的和。 三、简答题
java中的类的专题
(1)类的默认的无参构造函数[ ]。 A) 在任何情况下都存在 B) 仅当未定义无参构造函数时存在 C) 仅当未定义有参构造函数时存在 D) 仅当未定义任何构造函数时存在 (2) 类的默认的拷贝构造函数[ ]。 A) 在任何情况下都存在 B) 仅当未定义拷贝构造函数时存在 C) 仅当未定义有参构造函数时存在 D) 仅当未定义任何构造函数时存在 改错题：每题有一处错误，请在出错语句后用注释说明出错原因并提出更改意见(1)class Location { int X , Y ; protected: int SetZero(int zeroX, int zeroY); private: int length, height; public: void Location(int initX, int initY); int GetX( ); int GetY( ); }; （2）下面的程序有一处语法错误： #include
java四种方法事件监听(匿名类,外部类,内部类,自身)
JAVA四种方法实现事件监听 1.外部类实现事件监听： import java.awt.*; import java.awt.event.*; import javax.swing.*; publicclass Listener1extends JFrame { JButton button1,button2; JPanel pane1,pane2,p1,p2; CardLayout card1=new CardLayout(); /*CardLayout布局方式将容器中的每个组件看作一张卡片。 一次只能看到一张卡片，容器则充当卡片的堆栈*/ Listener1(){ this.setTitle("外部类实现事件监听"); this.setBounds(200,200,300,200); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setVisible(true); init(); } publicvoid init(){ p1=new JPanel(); p1.add(new JLabel("第一个面板")); p1.setBackground(Color.red); p2=new JPanel(); p2.add(new JLabel("第二个面板")); p2.setBackground(Color.green); pane1=new JPanel(card1); pane1.add("红色", p1); pane1.add("绿色", p2); button1=new JButton("红色"); button2=new JButton("绿色"); pane2=new JPanel(); pane2.add(button1); pane2.add(button2); this.add(pane1,BorderLayout.CENTER); this.add(pane2,BorderLayout.SOUTH); button1.addActionListener(new ColorEvent(card1,pane1));
JAVA中常用类的常用方法
JAVA中常用类的常用方法 一、https://www.wendangku.net/doc/0a16340839.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.wendangku.net/doc/0a16340839.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能：比较引用类型数据的等价性。 ?等价标准：引用类型比较引用，基本类型比较值。 ?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开
(完整版)C++复习题
复习题 一、选择填空 1．在下列关键字中，用来说明类中公有成员的是( )。 A． Public B． Private C． protected D． friend 答：A。 2．下列的各种函数中，( )不是类的成员函数。 A．构造函数 B．析构函数 C．友元函数 D．拷贝初始化构造函数答：C。 3．作用域运算符的功能是( )。 A．标识作用域的级别的 B．指出作用域的范围的 C．给定作用域的大小的 D．标识某个成员是属于哪个类的 答：D。 4．( )是不可以作为该类的成员的。 A．自身类对象的指针 B．自身类的对象 C．自身类对象的引用 D．另一个类的对象 答：B。 5．( )不是构造函数的特征。 A．构造函数的函数名与类名相同 B．构造函数可以重载 C．构造函数可以设置默认参数 D．构造函数必须指定类型说明 答：D。 6．( )是析构函数的特征。 A．一个类中只能定义一个析构函数 B．析构函数名与类名不同 C．析构函数的定义只能在类体内 D．析构函数可以有一个或多个参数 答：A。 7．通常的拷贝初始化构造函数的参数是( )。 A．某个对象名 B．某个对象的成员名 C．某个对象的引用名 D．某个对象的指针名 答：C。 8．关于成员函数特征的下述描述中，( )是错误的。 A．成员函数一定是内联函数 B．成员函数可以重载 C．成员函数可以设置参数的默认值 D．成员函数可以是静态的
答：A。 9．下述静态数据成员的特性中，( )是错误的。 A．说明静态数据成员时前边要加修饰符static B．静态数据成员要在类体外进行初始化 c.引用静态数据成员时，要在静态数据成员名前加＜类名＞和作用域运算 符 D．静态数据成员不是所有对象所共用的 答：D。 l0．友元的作用( )。 A．提高程序的运用效率 B．加强类的封装性 C．实现数据的隐藏性 D．增加成员函数的种类 答：A。 11．下列关于对象数组的描述中，( )是错误的。 A．对象数组的下标是从0开始的 B．对象数组的数组名是一个常量指针 C．对象数组的每个元素是同一个类的对象 D．对象数组只能赋初值，而不能被赋值 答案：D。 12．下列定义中，( )是定义指向数组的指针P。 A． int*p[5]； B． int(*p)[5]； C． (int *)p[5] D． int*p[]； 答案：B。 13．下列说明中 Const char * Ptr； ptr应该是( )。 A．指向字符常量的指针 B．指向字符的常量指针 C．指向字符串常量的指针 D．指向字符串的常量指针 答案：C。 14．已知：print( )函数是一个类的常成员函数，它无返回值，下列表示中是正确的。 A． void print()const ； B． const void Print( )； C． void const print( )； D． void print (const)； 答案：A。 15．关于new运算符的下列描述中，( )是错的。 A．它可以用来动态创建对象和对象数组 B．使用它创建的对象或对象数组，可以使用运算符delete删除