java中super关键字的两种用法
Java考试复习题
Java考试复习题JAVA程序设计练习一、填空题1、目前Java运行平台主要分为下列3个版本是Java se ,Java ee ,Java me 。
2、SDK平台提供的Java编译器是javac.exe 和Java解释器java.exe 位于Java安装目录的bin 文件夹中。
3、Java运行环境JRE由Java虚拟机、Java的核心类以及一些支持文件组成。
4、一个Java应用程序必须有一个称为主类的类,该类含有public static void main (String args[ ])方法。
5、在源文件的命名中如果源文件中有多个类,那么只能有一个类是public类;如果有一个类是public类,那么源文件的名字必须与这个类的名字完全相同,扩展名是java;6、一个Java Applet源文件不再需要main方法,但必须有且只有一个类扩展了Applet类,我们把这个类称作Java Applet源文件的主类。
7、类是组成Java程序的基本要素。
类封装了一类对象的状态和方法。
8、创建一个对象包括对象的声明和为对象分配成员变量两个步骤,对象的声明的一般格式为:类的名字对象名字;使用new运算符和类的构造方法为声明的对象分配成员变量9、用关键字static修饰的成员变量称作静态变量或类变量,类变量不仅可以通过某个对象访问也可以直接通过类名访问。
10、一个类中的方法可以互相调用:实例方法可以调用该类中实例方法或类方法;类方法只能调用该类的类方法,不能调用实例方法。
11、实例方法可以操作实例变量或类变量;而类方法只能操作类变量不能操作实例变量。
12、this关键字出现在类的构造方法中,代表使用该构造方法所创建的对象;this 关键字出现在类的实例方法中,代表使用该方法的当前对象。
13、成员变量在整个类内有效,局部变量仅在方法内有效,如果在方法内部局部变量的名字与成员变量的名字相同,则成员变量被隐藏,此时若要使用成员变量,格式为:this.成员变量。
Java简答题
Java简答题1、增强for循环在什么场合使用?用简单代码展现其使用方法。
参考答案:增强for循环可用来遍历数组或集合,如下所示:for(String s:sArray){System.out.println(s);}上述代码中的sArray是一个String类型的数组。
2、什么是泛型?泛型有什么作用?参考答案:泛型的本质就是参数化类型,也就是说把数据类型指定为一个参数。
在需要声明数据类型的地方,就可以不指定具体的某个类型,而是使用这个参数。
这样一来,就能够在具体使用时再指定具体类型,实现了参数的“任意化”。
泛型的好处是在编译的时候能够检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
3、线程之间通信的方法有哪几个?分别起到什么作用?参考答案:线程通信的方法有三个,在Object类中定义。
①wait 方法:使得线程进入等待状态。
②notify 方法:随意通知等待池中的某一个线程。
③no tifyAll 方法:通知等待池中所有线程。
4、使用java语言如何创建线程对象?请列出常用的两种方法。
参考答案:Java语言中经常使用两种方法创建线程。
①创建Thread类的子类,在子类中覆盖Thread类的run方法,实现线程的运行体,只要创建该子类对象就是线程对象。
②创建Runable接口的实现类,在实现类中覆盖接口中的run方法,实现线程的运行体。
使用Thread(Runable)构造方法可以创建线程对象,参数是Runable接口实现类的实例。
5、throws 关键字和 throw 关键字有什么区别和联系?参考答案:throw用来在方法体内抛出异常,而throws用来在方法声明处声明异常。
这两个关键字有着一定的联系。
如果一个方法中使用了throw关键字抛出了异常,那么要么立即用try/catch语句进行捕获,要么就是用throws进行声明,否则将出现编译错误。
然而,并不是只有使用了throw关键字之后才能使用throws关键字,语法上来说,任何一个方法都可以直接使用throws关键字,抽象方法也可以使用。
JAVA 习题题目及答案
第2章
作业题
1. 参照例 2-1 编写一个 Java 应用程序,输出俄文字母表。 2. 参照例 2-4 编写一个 Java 应用程序,用户从键盘只能输入整数,程序输出这些整数的乘 积。
第 3 章问答题及作业题
第 3 章 问答题
1、下列 System.out.printf 输出的结果是什么? int a=100,x,y; x=++a; y=a--; System.out.printf(“%d,%d,%d”,x,y,a); 2、下列哪些语句有错误? int x=0; x=5.0/2; float y=12.5F; y=5.0/2;
第 5 章问答题及作业题
第 5 章 问答题
1、子类在什么情况下可以继承父类的友好成员? 2、子类通过怎样的办法可以隐藏继承的成员变量? 3、子类重写继承的方法的规则是什么? 4、子类的构造方法的第一条语句是什么? 5、子类对象一旦重写了继承的方法,就会隐藏继承的方法,是这样吗? 6、子类重写继承的方法时,可以降低方法的访问权限吗? 7、关键字 super 的用法? 8、假设父类有一个方法? public double f(double x, double y){ return x+y; }
第 4 章问答题及作业题
第 4 章 问答题
1、在声明类时,类名应遵守哪些习惯? 2、类体内容有哪两种重要的成员?
3、实例方法可以操作类变量吗?类方法可以操作实例变量吗? 4、当类的字节码加载到内存时,类变量就一定分配了内存空间吗? 5、类的实例变量在什么时候会被封分配内存空间? 6、一个类的类变量被该类创建的所有对象共享吗? 7、不同对象的实例变量分配的内存空间地址一定不同吗? 8、什么叫方法重载?构造方法可以重载吗? 9、请阐述,为什么类方法不可以调用实例方法。 10、请阐述,为什么类方法不能操作实例成员变量。 11、实例方法可以用类名直接调用吗? 12、 关键字 this 可以出现在构造方法中吗?可以出现在实例方法中吗?可以出现在类方 法中吗? 13、源文件中声明编写的类一定在同一个包中吗? 14、 “import java.awt.*;”和“import java.awt.Button”有什么不同? 15、程序中如果使用了“import java.util.*” ,程序运行时,要加载 java.util 包中全部的 类到内存中吗? 16、有几种访问权限修饰符?说出其中一种修饰符的作用? 17、怎样反编译一个类?
Java中的两个关键字——super、this
Java中的两个关键字——super、thisJava中的两个关键字——super、this ⼀、supersuper 是java中⽅的⼀个关键字,⽤它可以引⽤⽗类中的成员:super可⽤于访问⽗类中定义的属性super可⽤于调⽤⽗类中定义的成员⽅法super可⽤于在⼦类构造器中调⽤⽗类的构造器使⽤super关键字注意事项:1、当⼦类和⽗类都有同名的属性时,在⼦类中如果要使⽤⽗类的属性 super . 属性2、 super只能应⽤在成员⽅法和构造⽅法中,不能⽤在静态⽅法中(和this是⼀样的)3、如果在构造⽅法中使⽤必须放在第⼀⾏4、在构造⽅法中this()和super()不能同时出现super没有什么需要解释的地⽅,我们⽤代码来看看super具体的⼀些强⼤功能吧⽰例⼀、使⽤super调⽤基类的属性:public class Father { int num=20;}public class Child extends Father{ int num; public void print(){ num=10; super.num=30; System.out.println("num="+num); System.out.println("="+super.num); }}public class Test { public static void main(String[] args) { Child xm=new Child(); xm.print(); }}运⾏结果:⽰例⼆、使⽤super调⽤基类中的构造⽅法:public class Father { int num; public Father() { System.out.println("⽗类中的⽆参构造⽅法---"); } public Father(int num){ System.out.println("⽗类中的有参的构造⽅法----"+num); }}public class Child extends Father{ int num; public Child() { super(30); System.out.println("⼦类⽆参构造⽅法---"); } public Child(int num) { this.num = num; System.out.println("⼦类中的有参的构造⽅法---"+num); }}解释⼀下上⾯的这段代码:在Child类中的第⼀个构造函数⾥⾯,super(30);它会去调⽤⽗类中嗲有⼀个int型参数的构造⽅法。
java语言程序设计(一)第三章补充
专接本辅导java第三章《面向对象编程基础》补充0.类变量与实例变量区别(类方法与实例方法的区别见习题解答第12题改错)java类的成员变量有两种:一种是被static关键字修饰的变量,叫类变量或者静态变量;另一种没有static修饰,为实例变量。
在语法定义上的区别:静态变量前要加static关键字,而实例变量前则不加。
在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。
静态变量不属于某个实例对象,而是属于类,所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就可以被使用了。
总之,实例变量必须创建对象后才可以通过这个对象来使用,静态变量则可以直接使用类名来引用。
例如,对于下面的程序,无论创建多少个实例对象,只在类被第一次装置时初始化一次staticVar变量和sum变量,并且每创建一个实例对象,就会执行一次构造函数;但是,每创建一个实例对象,就会分配一个instanceVar,即可能分配多个instanceVar,并且每个instanceVar的值都只自加了1次。
public class类变量与实例变量{public static int staticVar = 0;//类变量初始化,只会在类装载时进行一次!!public int instanceVar = 0;//实例变量初始化public static int sum=1;public类变量与实例变量()//构造方法{staticVar++;instanceVar++;sum=sum+5;System.out.println("staticVar = "+staticVar+",instanceVar="+instanceVar);System.out.println("sum = "+sum);}public static void main(String []args){类变量与实例变量对象1=new类变量与实例变量();类变量与实例变量对象2=new类变量与实例变量();类变量与实例变量对象3=new类变量与实例变量();}}运行结果:staticVar = 1,instanceVar=1sum = 6staticVar = 2,instanceVar=1sum = 11staticVar = 3,instanceVar=1sum = 16再如下面的程序,涉及static块:class Value{static int c=0;static int d;Value(){c=15;d=65;}Value(int i){c=i;d=c-1;}static void inc(){c++;}}public class Count {Value v0=new Value();//调用无参构造函数建立Value类非静态对象v0,类Count和类Value是has-a关系Value v=new Value(10);//调用有参构造函数建立Value类非静态对象vstatic Value v1,v2;//声明Value类的static对象v1,v2//static Value v1=new Value(),v2=new Value();//声明v1、v2并引用新建立的Value类对象static{//★声明static块,其初始化工作会先于任何其它非static块及非static变量而不管其在源程序书写中出现的先后次序!System.out.println("static块中println语句执行结果:"+"\n"+"v0和v是非静态内部类对象,v1和v2是静态内部类对象(请与教材P58例3.18对比),只有声明没有具体指向某对象时:v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);v1=new Value(30);//对象v1引用新建立的Value类对象System.out.println("static块中执行完“v1=new Value(30)之后:”v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);v2=new Value(15);//对象v2引用新建立的Value类对象System.out.println("static块中执行完“v2=new Value(15)之后:”v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);System.out.println("特别说明:因此时还没有建立Count类对象(Count 类和Value类是has-a关系,前者是外部类,后者是内部类)故非静态对象v0和v无法引用!"+"\n");}public static void main(String[] args) {Count ct1=new Count();//建立Count类(外部类)对象Count ct2=new Count();System.out.print("在main方法中,现在建立Count类(外部类)对象,");System.out.println("ct1的在ct2之前创建!分别指向两个Count类对象,Count类和Value类是has-a关系!"+"\n"+"以下是main方法体中println语句执行结果:");System.out.println("v0是无参构造内部类非静态对象,ct1.v0.c="+ct1.v0.c+" ct1.v0.d="+ct1.v0.d+" ct2.v0.c="+ct2.v0.c+"ct2.v0.d="+ct2.v0.d);// 非静态内部类对象只能通过外部类对象名访问System.out.println("v是有参构造内部类非静态对象,ct1.v.c="+ct1.v.c+" ct1.v.d="+ct1.v.d+" ct2.v.c="+ct2.v.c+" ct2.v.d="+ct2.v.d);// 非静态内部类对象只能通过外部类对象名访问System.out.println("v1是有参构造内部类静态对象,Count.v1.c="+Count.v1.c+" count.v1.d="+Count.v1.d);//静态内部类对象可以通过外部类名访问System.out.println("v2是有参构造内部类静态对象,Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);Value.inc();//通过类名调用类方法System.out.println("调用类方法inc()之后Count.v1.c="+Count.v1.c+" Count.v1.d="+Count.v1.d);//引用类变量既可以通过类名也可以通过对象名System.out.println("调用类方法inc()之后Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);Count.v2.inc();//通过类名调用类方法,这种写法不妥!System.out.println("调用类方法v1.inc()之后Count.v1.c="+Count.v1.c+" Count.v1.d="+Count.v1.d);//引用类变量既可以通过类名也可以通过对象名System.out.println("调用类方法v1.inc()之后Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);ct1.v0.c++;//this.v0.c++;//错误,★不能在静态上下文中使用this关键字:!因为Value是Count的内部类,只能使用其外部类的对象ct2.v0.c++;System.out.println("顺序执行语句:ct1.v0.c++;ct2.v0.c++;后,ct1.v0.c="+ct1.v0.c+" ct2.v0.c="+ct2.v0.c);// 非静态内部类对象只能通过外部类对象名访问}}上面这个程序的行动结果如下:static块中println语句执行结果:v0和v是非静态内部类对象,v1和v2是静态内部类对象(请与教材P58例3.18对比),只有声明没有具体指向某对象时:v1.c=0 v2.c=0 v1.d=0 v2.d=0static块中执行完“v1=new Value(30)之后:”v1.c=30 v2.c=30 v1.d=29 v2.d=29static块中执行完“v2=new Value(15)之后:”v1.c=15 v2.c=15 v1.d=14 v2.d=14特别说明:因此时还没有建立Count类对象(Count类和Value类是has-a关系,前者是外部类,后者是内部类)故非静态对象v0和v无法引用!在main方法中,现在建立Count类(外部类)对象,ct1的在ct2之前创建!分别指向两个Count类对象,Count类和Value类是has-a关系!以下是main方法体中println语句执行结果:v0是无参构造内部类非静态对象,ct1.v0.c=10 ct1.v0.d=9 ct2.v0.c=10 ct2.v0.d=9v是有参构造内部类非静态对象,ct1.v.c=10 ct1.v.d=9 ct2.v.c=10 ct2.v.d=9 v1是有参构造内部类静态对象, Count.v1.c=10 count.v1.d=9v2是有参构造内部类静态对象, Count.v2.c=10 count.v2.d=9调用类方法inc()之后 Count.v1.c=11 Count.v1.d=9调用类方法inc()之后 Count.v2.c=11 count.v2.d=9调用类方法v1.inc()之后 Count.v1.c=12 Count.v1.d=9调用类方法v1.inc()之后 Count.v2.c=12 count.v2.d=9顺序执行语句:ct1.v0.c++;ct2.v0.c++;后,ct1.v0.c=14 ct2.v0.c=14以上运行结果中,有五点值得注意:一是static变量和static块是在类第一次装载时被初始化一次,并供类的所有对象共享,故static变量和static块中内容最先被初始化(早于main方法)。
JAVA课后习题答案
JAVA课后习题答案第⼀章Java语⾔概述2.“java编译器将源⽂件编译为的字节码⽂件是机器码”这句话正确吗?答:不正确3.java应⽤程序的主类必须含有怎样的⽅法?答:含有main⽅法4。
“java应⽤程序必须有⼀个类是public类”这句话正确吗?答;不正确,只能有⼀个public类5。
“java Applet程序的主类必须是public类”这句话正确吗?答:正确,因为java Applet主类必须是Applet类的⼦类并且是public的类6。
请叙述java源程序的命名规则。
答:与public的类同名。
7。
源⽂件⽣成的字节码⽂件在运⾏时都加载到内存中吗?答:⾮也,动态随需要运⾏才加载。
8.⾯向对象的程序设计语⾔有那些基本特征?答:封装;继承;多态性。
9.在Java程序中有多个类⽂件时,⽤Java命令应该运⾏那个类?答:具有main⽅法的类第⼆章基本数据类型和数组4。
下列哪些语句是错的?Int x=120;Byte b=120;b=x;答:B=x;错应为b=(byte)x5。
下列哪些语句是错的?答:y=d;错,应y=(float)d6。
下列两个语句是等价的吗?Char x=97;Char x=…a?;答:是等价的。
7。
下列system.out.printf语句输出结果是什么?Int a=97;Byte b1=(byte)128;Byte b2=(byte)(-129);System.out.printf(“%c,%d,%d”,a,b1,b2);如果输出语句改为:System.out.printf(“%d,%d,%d”,a,b1,b2);输出什么?答:输出a ,-128,127修改后输出97,-128,1278.数组是基本数据类型吗?怎样获取数组的长度?答:不是基本数据类型,是复合数据类型。
可以通过:数组名.length的⽅法获得数组长度9。
假设有两个int类型数组:Int[] a=new int[10];Int[] b=new int[8];b=a;A[0]=100;B[0]的值⼀定是100吗?答;⼀定,因为a数组与b数组引⽤相同。
java中的this和super的作用和异同和C++中调用父类的构造函数
java中的this和super的作⽤和异同和C++中调⽤⽗类的构造函数这⼏天看到类在继承时会⽤到this和super,这⾥就做了⼀点总结,与各位共同交流,有错误请各位指正~thisthis是⾃⾝的⼀个对象,代表对象本⾝,可以理解为:指向对象本⾝的⼀个指针。
this的⽤法在java中⼤体可以分为3种:1.普通的直接引⽤这种就不⽤讲了,this相当于是指向当前对象本⾝。
2.形参与成员名字重名,⽤this来区分:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17class Person {private int age = 10;public Person(){System.out.println("初始化年龄:"+age);}public int GetAge(int age){this.age = age;return this.age;}}public class test1 {public static void main(String[] args) {Person Harry = new Person();System.out.println("Harry's age is "+Harry.GetAge(12)); }}运⾏结果:初始化年龄:10Harry's age is 12可以看到,这⾥age是GetAge成员⽅法的形参,this.age是Person类的成员变量。
3.引⽤构造函数这个和super放在⼀起讲,见下⾯。
supersuper可以理解为是指向⾃⼰超(⽗)类对象的⼀个指针,⽽这个超类指的是离⾃⼰最近的⼀个⽗类。
super也有三种⽤法:1.普通的直接引⽤与this类似,super相当于是指向当前对象的⽗类,这样就可以⽤super.xxx来引⽤⽗类的成员。
2.⼦类中的成员变量或⽅法与⽗类中的成员变量或⽅法同名12 3 4 5 6 7 8 9 10 11 12 13class Country {String name;void value() {name = "China";}}class City extends Country {String name;void value() {name = "Shanghai";super.value(); //调⽤⽗类的⽅法 System.out.println(name);13 14 15 16 17 18 19 20 21 System.out.println(name);System.out.println();}public static void main(String[] args) { City c=new City();c.value();}}运⾏结果:ShanghaiChina可以看到,这⾥既调⽤了⽗类的⽅法,也调⽤了⽗类的变量。
Java程序设计精编教程5-8章知识点
b) 如果变量名由多个单词组成,从第 2 个单词开始的每个单词的首字母要大写。
方法
方法的定义包括两部分:方法声明和方法体。一般格式为:
方法声明部分 {
方法体的内容
}
方法声明
方法声明包括返回值类型、方法名和参数。
double getArea() { //返回值类型为 double,无参数。
…
}
方法的返回值类型可以是 Java 中的任意数据类型。如果一个方法不返回数据,返回值类型必须是 void。
2. 有一个类 Singleton,为该类设计单例模式(该类只能有一个实例,且不能在类的外部 new 对象),只能通过该类 的静态方法 getInstance()获取该类的唯一对象。在主类 Homework2 中测试单例模式的有效性。
b) 在实例方法中,不仅可以调用实例方法,也可以调用类方法。 2) 类名调用类方法
a) 在类方法中,只能调用类方法、操作类变量。 b) 也可以通过对象调用类方法。 c) 如果一个方法不需要操作实例变量就可以实现某种功能,可以考虑将其声明为类方法。(例 5-8) 5.7 方法重载与多态 Java 中有两种多态:重载(overload)和重写(override)。 方法重载(overload):一个类中可以有多个名字相同的方法,但这些方法的参数必须不同,或者参数的个数不同, 或者参数的类型不同。方法的返回值类型与重载无关。
5.8 this 关键字 this 只能出现在实例方法和构造方法(也属于实例方法)中,表示调用该方法的当前对象。 一般情况下,方法中 this.实例变量的 this 可省略、类名.类变量的类名可省略,但当局部变量与成员变量同名时,
this 或类名不能省略。 5.9 包
包是 Java 语言管理类的一种机制,类似于操作系统中的目录,使用包名可以有效区分名字相同的类。 包语句
super(context, attrs)用法
超级调用super(context, attrs)在Android开发中,我们经常会看到在自定义View或ViewGroup的构造方法中使用super(context, attrs)这样的代码。
那么这个super(context, attrs)到底是什么意思,有什么作用呢?在本文中,我将向大家介绍super(context, attrs)的用法,并解释其作用和意义。
1. super(context, attrs)的基本概念在Java语言中,super关键字表示对父类的引用,我们可以使用super来调用父类中的构造方法、属性和方法。
而在Android中,通常在自定义View或ViewGroup的构造方法中使用super(context, attrs)来调用父类的构造方法。
其中,context代表上下文,attrs代表属性集合(AttributeSet)。
2. super(context, attrs)的作用当我们在自定义View或ViewGroup中使用super(context, attrs)时,实际上是在调用父类构造方法的将传入的context和attrs传递给父类,以便父类能够对这些参数进行处理。
这样做的好处是能够保证自定义View或ViewGroup具有与系统控件相似的属性初始化方式,同时也能够保证上下文的正确传递,使得自定义控件能够正确地与其他系统控件进行交互。
3. super(context, attrs)的应用场景在实际的Android开发中,我们经常会使用自定义View或ViewGroup来实现复杂的界面和交互效果。
而在这些自定义控件中,通常都需要使用super(context, attrs)来保证正确的初始化和交互。
我们经常会在自定义控件的构造方法中使用super(context, attrs)来调用父类构造方法,以便正确地处理传入的上下文和属性。
4. super(context, attrs)的注意事项在使用super(context, attrs)时,需要注意一些细节问题。
Java大学实用教程课后答案
Java大学实用教程课后答案第一章1.发明java的原因是什么,发明java的主要贡献者是谁?答:开发java语言的动力源于对独立平台的需要,即用这种语言编写的程序不会因为芯片的变化而发生无法运行或出现运行错误的情况。
当时,c语言已无法满足人们的这一愿望,因为c语言总是针对特定的芯片将源程序编译成机器码,该机器码的运行就与特定的芯片指令有关,在其他类型的芯片上可能无法运行或者运行出错。
主要贡献者是James Gosling。
2.“java编译器将源文件编译生成的字节码是机器码”,这句话正确吗?答:不正确,字节码是很接近机器码的二进制文件,不能被机器直接识别。
3. java应用程序的主类必须含有怎么样的方法?4. "java应用程序必须有一个类是public类".这句话正确吗?答:一个java应用程序必须有一个类含有public static void main(String args[] )方法,称为该应用程序的主类。
5. "java applet程序的主类必须是public类",这句话正确吗?不正确"java applet源文件的主类必须是public类",这句话正确吗?正确6. 叙述java源文件的命名法则。
答:(1)如果源文件中有多个类,那么只能有一个类是public类。
(2)如果有一个类是public类,那么源文件的名字必须和这个类的名字完全相同,扩展名为.java(3)如果源文件没有public类,那么源文件的名字只要和某个类的名字相同,并且扩展名为.java就可以了。
(4)java 语言区分大小写。
7. 源文件生成的的字节码运行时加载到内存中吗?8. 怎样编写加载运行java applet的简单网页?9. JDK1.6编译器使用"-source"参数的作用是什么,其默认的参数取值是什么?答:在编译源文件时使用"-source"参数来约定字节码适合的java 平台。
超全java面试题库-第一篇(Java基础篇)
第一篇Java基础面试题1.说下面向对象四大特性封装性、继承性、多态性、抽象性。
2.Java语言有些特点简单性:Java没有像C++那样的指针,运算符重载,类的多继承。
并且实现了垃圾的自动回收,简化了程序开发者对于内存管理的工作。
面像对象:对象是指封装数据和操作方法的程序实体。
Java提供了简单的类机制以及动态接口。
表现形式是封装继承多态。
分布式:它有一套很齐全的通信及相关功能的程序库,可以处理TCP/IP协议也可以处理其他的协议。
健壮性:用Java编写的程序能在多种情况下稳定运行。
Java在运行和编译的时候都会对可能出现的错误进行检查验证。
通过集成异常处理机制,在编译时提示可能出现的但是未被处理的异常,以防止系统的崩溃。
可移植性:Java是与平台无关的,Java类库中也实现了与平台无关的接口,这样类库也是可以移植的。
多线程机制:Java具有多线程机制,使得程序能够并行执行,同步机制也保证了数据的共享,线程也有优先级别,有利于使用线程级别控制不同的任务。
3.什么是Java程序的主类?应用程序和小程序的主类有何不同?一个程序中可以有多个类,但只能有一个主类。
在Java应用程序中,这个类是指包含main ()方法的类。
而在Java小程序中,这个主类是一个继承子系统类JApplet或Applet的子类。
应用程序的主类不一定要求是public类但小程序的主类必须是public类。
主类是Java程序执行的入口点。
简单说应用程序是从主线程启动(也就是 main() 方法)。
applet 小程序没有 main() 方法,主要是嵌在浏览器页面上运行(调用init()或者run()来启动),嵌入浏览器这点跟 flash 的小游戏类似。
4.访问修饰符public,private,protected,以及不写(默认)时的区别?类的成员不写访问修饰时默认为default。
默认对于同一个包中的其他类相当于公开(publi c),对于不是同一个包中的其他类相当于私有(private)。
面向对象答案
一、填空题101 Java中一个类可以有 1 个父类。
102 如果一个类的声明中没有使用extends关键字,这个类被系统默认为是Object 类的子类。
103 子类自然地继承了其父类中不是private 的成员变量作为自己的成员变量。
104 当子类中定义的成员变量和父类中的成员变量同名时,子类的成员变量隐藏了父类的成员变量。
105 子类通过成员变量的隐藏和方法的重写可以把父类的状态和行为改变为自身的状态和行为。
106 对于重写或继承的方法,Java运行时系统根据调用方法的实例的类型来选择调用哪个方法。
107 对于子类创建的一个对象,如果子类重写了父类的方法,则运行时系统调用子类的方法。
108 对于子类创建的一个对象,如果子类继承了父类的方法,未重写,则运行时调用父类的方法。
109 在Java语言中多态性体现在由方法重载实现的静态多态性和方法重写实现的动态多态性。
110 final 类不能被继承,即不能有子类。
111 abstract 类不能创建对象,必须产生其子类,由子类创建对象。
112 如果一个方法被修饰为final 方法,则这个方法不能被重写。
113 对于abstract 方法,只允许声明,而不允许实现。
114 如果一个方法被修饰为final方法,则这个方法不能被重写。
115 如果一个类是一个abstract类的子类,它必须具体实现父类的abstract方法。
116 局部变量的名字与成员变量的名字相同,若想在该方法内使用成员变量,必须使用关键字this 。
117 在关键字中能代表当前类或对象本身的是this 。
118 如果在子类中想使用被子类隐藏的父类的成员变量或方法可以使用关键字super 。
119 子类如果想用父类的构造方法,必须在子类的构造方法中使用,并且必须使用关键字super 来表示。
120 如果在子类中想使用被子类隐藏了的父类成员变量或方法就可以使用关键字super 。
121 Java中为了克服单继承的缺点,使用了接口,一个类可以实现多个接口。
Java中super关键字是什么?用来干什么?
Java中super关键字是什么?⽤来⼲什么?super 关键字含义super : 超级的含义:在Java中代表当前对象的直接⽗类对象的引⽤⽤法分类super.super(实际参数)1、super(实际参数)super():代表调⽤⽗类⽆参的构造super(参数):调⽤⽗类有参的构造作⽤:在⼦类构造⽅法中调⽤⽗类的构造⽅法特点:1.如果⼦类构造⽅法中的第⼀⾏没有this()或者this(参数),也不是super(参数)默认是super(),构造⽅法的第⼀⾏不是this(...)就是super(...)2.super()和super(参数)只能在构造⽅法的第⼀⾏注意: super()和super(参数)只能⽤在⼦类的构造⽅法中案例:package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {//Sub sub = new Sub();Sub sub = new Sub(10,20);// 在定义⼀个类的时候如果已经定义了有参构造在开发中⼀般要将⽆参数的构造⽅法补出来 }}// 定义⼀个⽗类class Super{int a;int b;//将构造public Super(){System.out.println("我是⽗类⽆参数的构造⽅法");}public Super(int a, int b) {System.out.println("我是⽗类有参数的构造⽅法");this.a = a;this.b = b;}//定义⼀个⼦类class Sub extends Super{int c;int d;//构造⽅法public Sub(){super(11,22);System.out.println("我是⼦类的⽆参数的构造⽅法");}public Sub(int c, int d) {super(11,22);System.out.println("我是⼦类的有参数的构造⽅法");this.c = c;this.d = d;}}案例2:package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {//Sub sub = new Sub();Sub sub = new Sub(10,20);// 在定义⼀个类的时候如果已经定义了有参构造在开发中⼀般要将⽆参数的构造⽅法补出来 }}// 定义⼀个⽗类class Super{int a;int b;//将构造public Super(){System.out.println("我是⽗类⽆参数的构造⽅法");}public Super(int a, int b) {System.out.println("我是⽗类有参数的构造⽅法");this.a = a;this.b = b;//定义⼀个⼦类class Sub extends Super{int c;int d;//构造⽅法public Sub(){super();System.out.println("我是⼦类的⽆参数的构造⽅法");}public Sub(int c, int d) {this();System.out.println("我是⼦类的有参数的构造⽅法");this.c = c;this.d = d;}}案例3:package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {//Sub sub = new Sub();Sub sub = new Sub(10,20);// 在定义⼀个类的时候如果已经定义了有参构造在开发中⼀般要将⽆参数的构造⽅法补出来 }}class YeYe{public YeYe(){System.out.println("我是yeye的构造⽅法");}}// 定义⼀个⽗类class Super extends YeYe{int a;int b;//将构造public Super(){super();System.out.println("我是⽗类⽆参数的构造⽅法");}public Super(int a, int b) {}//定义⼀个⼦类class Sub extends Super{int c;int d;//构造⽅法public Sub(){super();System.out.println("我是⼦类的⽆参数的构造⽅法"); }public Sub(int c, int d) {this();System.out.println("我是⼦类的有参数的构造⽅法"); this.c = c;this.d = d;}}2、super .作⽤:区分直接⽗类中和⼦类中重名的成员(成员变量和成员⽅法)案例:package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {Sub sub = new Sub();sub.m();}}class YeYe{int b = 1;}// 定义⼀个⽗类class Super extends YeYe{int b = 10;public int m1(){return super.b;}}int b = 20;public void m(){int b = 30;//System.out.println(b);//System.out.println(this.b);System.out.println(super.b);//super 指代当前⼦类的直接⽗类对象的引⽤ System.out.println(super.b);int i = m1();System.out.println(i);}}案例2:package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {Sub sub = new Sub();sub.m2();}}// 定义⼀个⽗类class Super{public void m1(){System.out.println("我是⽗类中的m1⽅法");}}//定义⼀个⼦类class Sub extends Super{// sub中有3个 b 成员变量@Overridepublic void m1(){System.out.println("我是⼦类重写⽗类的m1⽅法");}public void m2(){//this.m1();//this.m1()super.m1();}}总结super: 当前类的直接⽗类对象的引⽤1. 只能⽤在构造⽅法中2. 只能是构造⽅法的第⼀条有效语句3. 如果⼀个构造⽅法的第⼀⾏不是 this() / this(实参) / super(实参),默认是super()2、super. : 当⼦类中存在和⽗类同名的成员变量,需要使⽤super 指定⽗类的重名的成员变量.。
java super方法
(原创实用版5篇)编制人员:_______________审核人员:_______________审批人员:_______________编制单位:_______________编制时间:____年___月___日序言下面是本店铺为大家精心编写的5篇《java super方法》,供大家借鉴与参考。
下载后,可根据实际需要进行调整和使用,希望能够帮助到大家,谢射!(5篇)《java super方法》篇1Java中的`super`关键字可以用来调用父类中的方法或属性。
在子类中,可以通过`super`关键字来调用父类中的方法,也可以使用`super`关键字来访问父类中的属性。
使用`super`关键字调用父类中的方法,语法如下:```javasuper.methodName(arguments);```其中,`methodName`是要调用的父类方法名,`arguments`是该方法的参数列表。
例如,如果父类中有一个名为`printMessage`的方法,子类可以通过以下方式调用该方法:```javasuper.printMessage();```使用`super`关键字访问父类中的属性,语法如下:```javasuper.propertyName;```其中,`propertyName`是要访问的父类属性名。
《java super方法》篇2在Java中,`super`关键字用于引用父类中的成员变量和方法。
使用`super`关键字可以访问父类中的成员变量和方法,从而可以在子类中重写父类的方法。
`super`关键字有两种用法:1. `super.methodName()`:调用父类中的方法。
2. `super.fieldName`:访问父类中的成员变量。
以下是一个示例,演示如何在子类中使用`super`关键字:```javapublic class Animal {public void move() {System.out.println("Animal is moving");}}public class Dog extends Animal {public void move() {super.move(); // 调用父类中的move()方法System.out.println("Dog is running");}}```在上面的示例中,`Dog`类继承自`Animal`类,并重写了`move()`方法。
Java中this和super的用法详解
Java中this和super的⽤法详解前⾔这次我们来回顾⼀下this和super这两个关键字的⽤法,作为⼀名Java程序员,我觉得基础是最重要的,因为它决定了我们的上限,所以我的⽂章⼤部分还是以分享Java基础知识为主,学好基础,后⾯的知识我想学起来就变得简单。
废话不多说,进⼊正⽂。
thisthis 关键字只能在⽅法内部使⽤,表⽰对调⽤⽅法的那个对象的引⽤。
其实简单来说 this 关键字就是表⽰当前对象,下⾯我们来具体介绍 this 关键字在Java中的⽤法。
1、调⽤成员变量在⼀个类的⽅法内部,如果我们想调⽤其成员变量,不⽤ this,我们会怎么做?public class ThisTest {private String name = "xiaoming";public String getName() {return name;}public void setName(String name) {name = name;}}看上⾯的代码,我们在ThisTest类中创建了⼀个name属性,然后创建了⼀个setName⽅法,注意这个⽅法的形参也是String name,那么我们通过name = name这样赋值,会改变成员变量name的属性吗?public static void main(String[] args) {ThisTest thisTest = new ThisTest();thisTest.setName("xiaoma");System.out.println(thisTest.getName());}打印结果是xiaoming,⽽不是我们重新设置的xiaoma,显然这种⽅式是不能在⽅法内部调⽤到成员变量的。
因为形参的名字和成员变量的名字相同,setName⽅法内部的name = name,根据最近原则,编译器默认是将这两个name属性都解析为形参name,从⽽导致我们设值操作和成员变量name完全没有关系,当然设置不了。
super用法
super用法Super用法Super是Python中的一个关键字,它可以用来调用父类中的方法或属性。
在继承中,如果子类和父类都有同名的方法或属性,子类会覆盖掉父类的方法或属性。
但是有时候我们需要在子类中调用父类中被覆盖的方法或属性,这时候就可以使用super关键字。
一、使用super调用父类方法1.1 super()函数super()函数可以返回一个临时对象,这个对象是当前类和父类之间的一个代理。
通过这个代理对象,我们可以调用父类中的方法。
语法:```pythonsuper().method(args)```其中method是要调用的父类方法名,args是传递给该方法的参数。
示例:```pythonclass A:def greet(self):print("Hello, I am A.")class B(A):def greet(self):super().greet()print("Hello, I am B.")b = B()b.greet()```输出结果为:```Hello, I am A.Hello, I am B.在B中重写了greet()方法,并使用super()函数调用了A中的greet()方法。
1.2 调用指定父类如果有多个父类,我们也可以指定要调用哪个父类的方法。
语法:```pythonsuper(ClassName, self).method(args)```其中ClassName是要指定要调用哪个父类的类名,self是当前对象。
示例:```pythonclass A:def greet(self):print("Hello, I am A.")class B:def greet(self):print("Hello, I am B.")class C(A, B):def greet(self):super(B, self).greet()print("Hello, I am C.")c = C()c.greet()```输出结果为:```Hello, I am A.Hello, I am C.```在C中重写了greet()方法,并使用super(B, self)调用了B中的greet()方法。
mockito super方法
mockito super方法Mockito是一个Java框架,可以用于编写单元测试代码时对依赖对象进行模拟。
它提供了一系列的功能,方便我们创建、配置和验证模拟对象的行为。
在Mockito中,我们可以使用`super`关键字来模拟父类的方法调用。
当我们需要模拟一个方法时,可以使用`when`-`thenReturn`结构来设置对方法的调用的预期结果。
而当我们需要调用父类的方法时,可以使用`super`关键字来调用真正的父类方法。
在使用`super`方法进行模拟时,我们首先需要模拟一个父类的实例。
我们可以通过`mock`方法创建一个模拟对象,并指定父类的类型。
然后,我们可以使用`when`-`thenReturn`结构来设置对模拟对象方法的调用的预期结果。
例如,假设我们有一个父类`ParentClass`和一个子类`ChildClass`,子类`ChildClass`中重写了父类的某个方法`doSomething`,我们想要模拟`doSomething`方法,但同时又需要调用真正的父类方法。
我们可以通过以下代码来实现:```javaParentClass parentMock = Mockito.mock(ParentClass.class);ChildClass child = new ChildClass(;Mockito.when(parentMock.doSomething().thenCallRealMethod(;child.doSomething(;Mockito.verify(parentMock).doSomething(;```在这个例子中,我们首先创建了一个父类的模拟对象`parentMock`。
然后,我们使用`when`-`thenCallRealMethod`结构来设置对`parentMock.doSomething`方法的调用的预期结果,即调用真正的父类方法。
接下来,我们创建了一个子类的实例`child`,并调用了`child.doSomething`方法。
?extendsT和?superT的使用
extendsT和?superT的使⽤阿⾥规范中有⼀个12.【强制】泛型通配符<? extends T>来接收返回的数据,此写法的泛型集合不能使⽤ add ⽅法,⽽<? super T>不能使⽤ get ⽅法,两者在接⼝调⽤赋值的场景中容易出错。
具体的分析可以看下如下:最终PECS (Producer Extends Consumer Super ) 原则频繁往外读取内容的,适合⽤上界Extends。
经常往⾥插⼊的,适合⽤下界Super。
<? extends T> 和 <? super T> 是Java泛型中的“通配符(Wildcards)” 和 “边界(Bounds)”的概念<? extends T> 是指 “上界通配符(Upper Bounds Wildcards)”<? super T> 是指 “下界通配符(Lower Bounds Wildcards)”1. 为什么要⽤通配符和边界?使⽤泛型的过程中,经常出现⼀种很别扭的情况。
⽐如,我们有Fruit类,和它的派⽣类Apple类。
class Fruit {}class Apple extends Fruit {}然后有⼀个最简单的容器:Plate类。
盘⼦⾥可以放⼀个泛型的“东西”。
我们可以对这个东西做最简单的“放”和“取”的动作:set()和get()⽅法。
public class Plate<T> {private T item;public Plate(T t) {this.item = t;}public T get() {return item;}public void set(T item) {this.item = item;}}现在我定义⼀个“⽔果盘⼦”,逻辑上⽔果盘⼦当然可以装苹果。
Plate<Fruit> p=new Plate<Apple>(new Apple());但实际上Java编译器不允许这个操作。
super 用法
super 用法Super是Python中一个非常有用的关键字,它可以用来调用父类的方法和属性。
在Python中,每个类都有一个父类,如果没有指定父类,则默认为object类。
当我们在子类中定义一个方法或属性时,如果想要调用父类中的同名方法或属性,就可以使用super关键字。
使用super关键字的语法如下:super().method(args)其中,method是要调用的父类方法的名称,args是传递给该方法的参数。
如果父类方法不需要参数,则可以省略args。
下面是一个示例代码,演示了如何使用super关键字调用父类方法:```class Parent:def __init__(self, name): = namedef say_hello(self):print("Hello, my name is", )class Child(Parent):def __init__(self, name, age):super().__init__(name)self.age = agedef say_hello(self):super().say_hello()print("I am", self.age, "years old")child = Child("Tom", 10)child.say_hello()```在上面的代码中,我们定义了一个Parent类和一个Child类,Child 类继承自Parent类。
在Child类的构造函数中,我们使用super关键字调用了父类的构造函数,以初始化父类中的属性。
在Child类的say_hello方法中,我们首先使用super关键字调用了父类的say_hello方法,然后再输出了自己的年龄。
使用super关键字的好处是,它可以自动找到父类,无需显式指定父类的名称。
这样,当我们修改类的继承关系时,代码也不需要修改,因为super关键字会自动调用新的父类的方法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
setName(name);
//你可以加上this来调用方法,像这样:this.setName(name);但这并不是必须的
public int c;
private String name;
private int age;
protected void setName(String name){
=name;
}
protected void setAge(int age){
DemoThis dt=new DemoThis("Kevin","22");
这段代码很简单,不用解释你也应该能看明白。在构造函数中你看到用this.print(),
你完全可以用print()来代替它,两者效果一样。下面我们修改这个程序,来演示super的用法。
class Person{
public void print(){
System.out.println("DemoSuper:");
super.print();
}
public static void main(String[] args){
DemoSuper ds=new DemoSuper();
ds.setName("kevin");
ds.setAge(22);
ds.print();
}
}
本篇文章来自Java中文网:/language/java/182383.shtml
好了,现在开始讨论this&super这两个关键字的意义和用法。
在Java中,this通常指当前对象,super则指父类的。
当你想要引用当前对象的某种东西,比如当前对象的某个方法,或当前对象的某个成员,你便可以利用this来实现这个目的,当然,this的另一个用途是调用当前对象的另一个构造函数,这些马上就要讨论。
}
public void print(){
System.out.println("Name="+name+" ge="+age);
//在此行中并不需要用this,因为没有会导致混淆的东西
}
public static void main(String[] args){
如果你想引用父类的某种东西,则非super莫属。
由于this与super有如此相似的一些特性和与生俱来的某种关系,所以我们在这一块儿来讨论,希望能帮助你区分和掌握它们两个。
在一般方法中
最普遍的情况就是,在你的方法中的某个形参名与当前对象的某个成员有相同的名字,这时为了不至于混淆,你便需要明确使用this关键字来指明你要使用某个成员,使用方法是“this.成员名”,而不带this的那个便是形参。另外,还可以用“this.方法名”来引用当前对象的某个方法,但这时this就不是必须的了,你可以直接用方法名来访问那个方法,编译器会知道你要调用的是那一个。下面的代码演示了上面的用法:
教程由JAVA中文网整理校对发布()
通过用static来定义方法或成员,为我们编程提供了某种便利,从某种程度上可以说它类似于C语言中的全局函数和全局变量。
但是,并不是说有了这种便利,你便可以随处使用,如果那样的话,你便需要认真考虑一下自己是否在用面向对象的思想编程,自己的程序是否是面向对象的。
setAge(age);
this.print(); br> }
public void setName(String name){
=name;//此处必须指明你要引用成员变量
}
public void etAge(int age){
this.age=age;
this.age=age;
}
protected void print(){
System.out.println("Name="+name+" Age="+aglass DemoSuper extends Person{