- 浏览: 172112 次
- 性别:
- 来自: 成都
文章分类
最新评论
-
gwill_21:
dwr.xml找不到怎么办,难道要自己手写dwr.xml?痛苦 ...
DWR框架 —— 用户注册验证 -
recoba7:
MLDN魔乐科技 Oracle学习笔记 (5) -
lanni2460:
呵呵 尽管现在才看到这个 但是我真的觉得 李老师 讲的很好呢 ...
严重声明,那些恶意诋毁MLDN及李兴华老师的其他培训机构统统走开 -
chian_xxp:
只要把功能实现了,代码结构合理了,代码性能提高了,该注意的注意 ...
业务、业务、业务。。。 -
wzpbb:
密码多少啊??? 给一下啊
MLDN 魔乐科技 Oracle 学习笔记(2)
今天所讲的知识点
A static关键字:六个用法分析
B 对象数组:定义和使用及内存分配图分析
C JDK 1.5对数组的新支持:foreach和可变参数
D 代码块:普通代码块、构造代码块、静态代码块
E 内部类
我对知识点的分析
A static关键字的用法一:
(1)当希望创建的所有对象共用一个属性的时候,可以把此属性设置为static属性;
(2)此时,此属性可以采用“类名.static属性名”直接使用;
(3)并且此属性值存放在全局数据区;
(4)在本类中访问此属性,可以不加“this.”修饰
static关键字的用法二:
(1)static除了可以修饰属性外,还可以修饰方法
(2)不过用static修饰的方法使用时有局限性,只能访问和调用同样用static修饰的属性和方法,不可调用非static的属性和方法
(3)不过非static的方法却可以访问和调用用static修饰的属性和方法,如果是本类中的不用加“this.”修饰,如果是非本类中的加上“类名.”修饰
static关键字的用法三:
(1)主方法main必须用static修饰
(2)如果希望在主类中定义的方法在main方法中能够直接调用,则定义的时候必须加上static修饰
(3)如果希望在主类中定义的方法在main方法中能够直接调用,但在定义的时候又不加static修饰,那么只能通过实例化一个匿名的主类对象来调用此方法,如:new 主类名().非static的方法名(参数);
static关键字的用法四:
(1)可以通过static定义静态代码块
(2)主类中的静态块优先于主方法执行,其他类中静态块在实例化对象的时候自动调用执行并且优先于构造块执行,不管有多少个对象产生,静态块只执行一次。
static关键字的用法五:
(1)用static修饰内部类
(2)使用static声明的内部类就成为外部类,这样在需要实例化内部类的时候就非常简单,格式为:
外部类.内部类名 对象名=new外部类.内部类名(参数列表);
static关键字的用法六:
(1)用加static修饰的属性来统计生成对象的个数;
例如:private static int Count=0;
方法是在无参构造方法中加Count++;
然后在其他构造方法中调用此构造方法:this();这样就可以通过Count属性知道产生对象的个数;
(2)还可以利用这点来完成某个对象名称的自动命名操作
例如:
class Book{
private String title ;
private static int count = 0 ; // 用于记录有多少个对象产生
public Book(){
this.title = "title-" + count++ ;
}
public Book(String title){
this.setTitle(title) ;
}
public void setTitle(String title){
this.title = title ;
}
public String getTitle(){
return this.title ;
}
public static int getCount(){
return count ;
}
};
B 1、对象数组的定义格式:
类名称 对象数组名称[] = new 类名称[长度] ;
2、但是通过以上的定义语句只是声明了一个对象数组的名字,而每一个数组元素的值为null,例如:
每一个元素的名称又相当于每一个对象名,这个时候只是相当于声明了对象名一样,并没有对对象进行实例化,这个时候每个元素并没有具体的指向,所以都为null;
只有经过给每个元素实例化以后,采用使用每一个元素,也即每一个元素才有真正的指向;例如:
或者
C JDK 1.5对数组的新支持:foreach和可变参数
1、foreach是for的增强版,专门为遍历数组或集合中的值或对象而设置的。
语法:
for (类型 变量名称:数组或集合){
…..
}
说明:
(1)类型与数组或集合的类型一致,可以是基本数据类型也可以是引用数据类型;
(2)在循环过程中该变量依次代表数组或集合中的每一个元素;
2、可变参数
(1)在定义方法的时候可以不指定具体的参数个数,而是在调用的时候随意传入n个数据类型(0<=n<=任意个数);
(2)如果定义方法的时候有确定的参数和可变参数一起使用,那么可变参数必须放在最后一个参数位置;
(3)一组可变参数具有相同的数据类型;
(4)其实这组可变参数最终将以数组的形式接收;
(5)可变参数的数据类型可以是基本数据类型,也可以是引用数据类型;
例如:
public class Test3
{
public static void main(String args[]){
print("aa",2,3,4,5);
}
public static void print(String str, int...y){
System.out.println(str);
for(int i:y){
System.out.println(i);
}
}
}
D 在程序中使用“{}”括起来的代码称为代码块。根据位置及声明的不同,代码块分为以下四种:
• 普通代码块
• 构造块
• 静态代码块
• 同步代码块,其中此代码块将在多线程部分进行讲解
1、普通代码块
在某个方法中单独用“{}”括起来的代码称为普通代码块。
主要作用是使得某些变量具有局部作用域;
例如:
注意:
(1)在普通代码块中定义的局部变量如果和在方法中直接定义的变量重名,那么普通代码块必须在其之前,否则会报错;
例如:
public class Test3{
public static void main(String args[]){
int x = 100 ;
System.out.println("x = " + x) ;
{ // 普通代码块
int x = 10 ; // 局部变量
System.out.println("x = " + x) ;
}
}
};
报错信息:
已在 main(java.lang.String[]) 中定义 x
int x = 10 ; // 局部变量
^
(2)普通代码块所在方法被调用后,方法中的语句顺序执行,普通代码块中的语句不会优先被执行;
2、构造块
在某个类中,并且在方法外使用“{}”括起来的代码称为构造块。
注意:
(1)构造块总是优先于构造方法执行,不管两者的位置上下关系如何;
(2)而且每一个实例化对象产生时,都会自动调用构造块,会重复调用多次。
(3)定义构造块的位置为在某个类中,但在所有方法外,因为如果在某个方法内,就成了普通代码块了。
例如:
class Demo{
private int i;
public Demo(){
System.out.println("构造方法。") ;
}
public Demo(int i){
System.out.println("构造方法。"+i) ;
}
{ // 构造块
System.out.println("构造块") ;
}
};
public class Test3{
public static void main(String args[]){
new Demo() ;
new Demo(2) ;
new Demo() ;
}
};
3、静态块
在类中并且在方法外使用static声明的代码块称为静态代码块。
(1)定义静态块必须加static关键字,否则为构造块;
(2)定义静态块的位置必须是在类中,但在所有方法外,如果在方法内会报错;
例如:
public class Test3{
public static void main(String args[]){
static{
System.out.println("主方法中的静态块");
}
}
};
报错信息:
非法的表达式开始
static{
^
(3)主类中的静态块优先于主方法执行,其他类中静态块在实例化对象的时候自动被执行,并且优先于构造块执行,不管有多少个对象产生,静态块只执行一次。
class Demo{
{ // 构造块
System.out.println("构造块") ;
}
public Demo(){
System.out.println("构造方法。") ;
}
static{ // 静态块
System.out.println("静态代码块") ;
}
};
public class Test3{
public static void main(String args[]){
System.out.println("-------------------------") ;
new Demo() ;
new Demo() ;
}
static{
System.out.println("\n\n在主类中定义的静态块") ;
}
};
运行结果:
在主类中定义的静态块
-------------------------
静态代码块
构造块
构造方法。
构造块
构造方法。
构造块
构造方法。
E 1、内部类的概念
内部类即表示在一个类的定义中包含了另一个类的定义;
2、内部类的定义格式
(1)在类中定义内部类
缺点:①打破了常规类的定义格式(类中只有属性和方法);
②增加了外部类的负担;
优点:在内部类中可以直接访问外部类中的私有成员;
(2)在方法中定义内部类
同样,优点在于在内部类中可以直接访问外部类中的私有成员;
但是需要注意的一点:
在定义内部类的方法中需要带参数,或者需要定义变量,则必须带final修饰符;
例如:
class Outer{
private String info = "Hello World!!!" ;
public void fun(int temp){ // 方法中的参数
String flag = "MLDN" ; // 方法中的变量
class Inner{ // 在方法中定义内部类
public void print(){
System.out.println("temp = " + temp) ;
System.out.println("flag = " + flag) ;
System.out.println("info = " + info) ;
}
};
new Inner().print() ;
}
};
public class Test3{
public static void main(String arg[]){
new Outer().fun(30) ;
}
};
报错信息:
从内部类中访问局部变量 temp;需要被声明为最终类型
System.out.println("temp = " + temp) ;
^
从内部类中访问局部变量 flag;需要被声明为最终类型
System.out.println("flag = " + flag) ;
^
修改代码:
class Outer{
private String info = "Hello World!!!" ;
public void fun(final int temp){ // 方法中的参数
final String flag = "MLDN" ; // 方法中的变量
class Inner{ // 在方法中定义内部类
public void print(){
System.out.println("temp = " + temp) ;
System.out.println("flag = " + flag) ;
System.out.println("info = " + info) ;
}
};
new Inner().print() ;
}
};
public class Test3{
public static void main(String arg[]){
new Outer().fun(30) ;
}
};
3、实例化内部对象
(1)在外部要实例化内部类的对象,必须先实例化外部类对象,然后通过外部类的实例化对象去实例化内部类的对象;
例如:
class Outer{
private String info = "Hello World!!!" ;
class Inner{ // 内部类
public void print(){
System.out.println(info) ;
}
};
};
public class InnerClassDemo03{
public static void main(String arg[]){
Outer out = new Outer() ; // 产生外部类实例
Outer.Inner in = null ; // 声明内部类对象
in = out.new Inner() ; // 实例化内部类对象
in.print() ;
}
};
(2)如果想要在外部直接实例化内部类,而不通过外部类的实例化对象,则可以把内部类声明为static;
注意:
①使用static声明的内部类就成为外部类,可以不通过外部类的实例化对象直接实例化内部类的对象;
例如:
class Outer{
private static String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
public void print(){
System.out.println(info) ;
}
};
};
public class InnerClassDemo06{
public static void main(String arg[]){
Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
in.print() ;
}
};
②当把内部类声明为static类之后,在内部类中如果要直接访问外部类的属性和方法,则只能访问外部类中也标记为static的属性和方法,否则编译通不过;
例如:
class Outer{
private String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
public void print(){
System.out.println(info) ;
}
};
};
public class Test3{
public static void main(String arg[]){
Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
in.print() ;
}
};
报错信息:
无法从静态上下文中引用非静态 变量 info
System.out.println(info) ;
^
修改方法:
class Outer{
private static String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
public void print(){
System.out.println(info) ;
}
};
};
public class Test3{
public static void main(String arg[]){
Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
in.print() ;
}
};
③当内部类被声明为static之后,并不表示内部类中的非static方法自动转换成static级别的了,虽然其只能访问外部类中标记为static的属性和方法,他仍然可以访问内部类中的非static的属性和方法;
例如:
class Outer{
private static String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
public void print(){
System.out.println(info) ;
}
};
};
public class Test3{
public static void main(String arg[]){
Outer.Inner.print();
}
};
报错信息:
无法从静态上下文中引用非静态 方法 print()
Outer.Inner.print();
^
例如:
class Outer{
private static String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
private int i=10; //内部类中的非static的属性
public void print(){
System.out.println(info+i) ; //可以访问内部类中的非static的属性
}
};
};
public class Test3{
public static void main(String arg[]){
Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
in.print() ;
}
};
项目案例:
A 1.使用运行时参数的形式完成一个简单的登陆程序:
例如:输入:java LoginDemo 用户名 密码
假设,用户名是abc,密码是123,如果正确则显示登陆成功,否则显示登陆失败。
本题目要求合理的考虑类的划分
个人收获:
学会了利用main()方法的参数利用
案例名称:
B 2、给出以下的操作代码,可以在Single类中增加任意的代码,只要可以在主方法处调用里面的打印方法即可。
class Single {
private Single(){}
public void print(){
System.out.println("Hello World!!!") ;
}
};
public class SingleDemo{
public static void main(String args[]){}
};
个人收获:
体会了static关键字修饰方法的作用
案例名称:
C 使用Java的引用完成以下一种代码的开发
(NODE)-->(NODE)-->(NODE )
如果此种关系表示成功之后,现在就要求完成一个可以动态增加节点的操作类,此类可以完成以下功能:
(1)增加节点,在最后增加
(2)查找节点:判断指定的节点是否存在,节点中通过节点名称判断
(3)删除节点
(4)输出全部节点
提示:可以使用内部类方便的完成。
个人收获:
把以前学过的链表(结点)的数据结构知识利用了起来;
并且再次体会了内部类的特点和作用。
今天出现的问题
A class Demo
{
static{
public static void Just1(){
System.out.println("啊啊啊啊啊啊啊啊啊啊啊啊");
}
}
{
public static void Just2(){
System.out.println("啊啊啊啊啊啊啊啊啊啊啊啊");
}
}
public void print(){
{
public static void Just3(){
System.out.println("啊啊啊啊啊啊啊啊啊啊啊啊");
}
}
}
}
解决方法:
得出结论:在普通代码块、构造块、静态块中都不能定义方法
在做题的时候发现,自己不能灵活的运用所学的知识。对于所讲的知识点基本能掌握,也似乎都理解,只是运用起来总感觉隔着一层膜,不是那么透彻,特别是this,内部类这几个地方,有些模糊。还需要加强代码的练习,培养感觉。
现在我把每天的日志编写当成了整理笔记和复习当天所学的知识,并且整理自己对知识点的理解和归纳总结。这样既可以对一天所学的知识有个整体的印象,也加深了记忆。
每天晚上睡觉之前,基本都会简单回忆一遍一天所学的新概念及应该注意的地方。
今天做作业第三题的时候,慢慢开始体会面向对象编程的特点和思路。虽然还不是恨透,不过有点感觉了。
A static关键字:六个用法分析
B 对象数组:定义和使用及内存分配图分析
C JDK 1.5对数组的新支持:foreach和可变参数
D 代码块:普通代码块、构造代码块、静态代码块
E 内部类
我对知识点的分析
A static关键字的用法一:
(1)当希望创建的所有对象共用一个属性的时候,可以把此属性设置为static属性;
(2)此时,此属性可以采用“类名.static属性名”直接使用;
(3)并且此属性值存放在全局数据区;
(4)在本类中访问此属性,可以不加“this.”修饰
static关键字的用法二:
(1)static除了可以修饰属性外,还可以修饰方法
(2)不过用static修饰的方法使用时有局限性,只能访问和调用同样用static修饰的属性和方法,不可调用非static的属性和方法
(3)不过非static的方法却可以访问和调用用static修饰的属性和方法,如果是本类中的不用加“this.”修饰,如果是非本类中的加上“类名.”修饰
static关键字的用法三:
(1)主方法main必须用static修饰
(2)如果希望在主类中定义的方法在main方法中能够直接调用,则定义的时候必须加上static修饰
(3)如果希望在主类中定义的方法在main方法中能够直接调用,但在定义的时候又不加static修饰,那么只能通过实例化一个匿名的主类对象来调用此方法,如:new 主类名().非static的方法名(参数);
static关键字的用法四:
(1)可以通过static定义静态代码块
(2)主类中的静态块优先于主方法执行,其他类中静态块在实例化对象的时候自动调用执行并且优先于构造块执行,不管有多少个对象产生,静态块只执行一次。
static关键字的用法五:
(1)用static修饰内部类
(2)使用static声明的内部类就成为外部类,这样在需要实例化内部类的时候就非常简单,格式为:
外部类.内部类名 对象名=new外部类.内部类名(参数列表);
static关键字的用法六:
(1)用加static修饰的属性来统计生成对象的个数;
例如:private static int Count=0;
方法是在无参构造方法中加Count++;
然后在其他构造方法中调用此构造方法:this();这样就可以通过Count属性知道产生对象的个数;
(2)还可以利用这点来完成某个对象名称的自动命名操作
例如:
class Book{
private String title ;
private static int count = 0 ; // 用于记录有多少个对象产生
public Book(){
this.title = "title-" + count++ ;
}
public Book(String title){
this.setTitle(title) ;
}
public void setTitle(String title){
this.title = title ;
}
public String getTitle(){
return this.title ;
}
public static int getCount(){
return count ;
}
};
B 1、对象数组的定义格式:
类名称 对象数组名称[] = new 类名称[长度] ;
2、但是通过以上的定义语句只是声明了一个对象数组的名字,而每一个数组元素的值为null,例如:
每一个元素的名称又相当于每一个对象名,这个时候只是相当于声明了对象名一样,并没有对对象进行实例化,这个时候每个元素并没有具体的指向,所以都为null;
只有经过给每个元素实例化以后,采用使用每一个元素,也即每一个元素才有真正的指向;例如:
或者
C JDK 1.5对数组的新支持:foreach和可变参数
1、foreach是for的增强版,专门为遍历数组或集合中的值或对象而设置的。
语法:
for (类型 变量名称:数组或集合){
…..
}
说明:
(1)类型与数组或集合的类型一致,可以是基本数据类型也可以是引用数据类型;
(2)在循环过程中该变量依次代表数组或集合中的每一个元素;
2、可变参数
(1)在定义方法的时候可以不指定具体的参数个数,而是在调用的时候随意传入n个数据类型(0<=n<=任意个数);
(2)如果定义方法的时候有确定的参数和可变参数一起使用,那么可变参数必须放在最后一个参数位置;
(3)一组可变参数具有相同的数据类型;
(4)其实这组可变参数最终将以数组的形式接收;
(5)可变参数的数据类型可以是基本数据类型,也可以是引用数据类型;
例如:
public class Test3
{
public static void main(String args[]){
print("aa",2,3,4,5);
}
public static void print(String str, int...y){
System.out.println(str);
for(int i:y){
System.out.println(i);
}
}
}
D 在程序中使用“{}”括起来的代码称为代码块。根据位置及声明的不同,代码块分为以下四种:
• 普通代码块
• 构造块
• 静态代码块
• 同步代码块,其中此代码块将在多线程部分进行讲解
1、普通代码块
在某个方法中单独用“{}”括起来的代码称为普通代码块。
主要作用是使得某些变量具有局部作用域;
例如:
注意:
(1)在普通代码块中定义的局部变量如果和在方法中直接定义的变量重名,那么普通代码块必须在其之前,否则会报错;
例如:
public class Test3{
public static void main(String args[]){
int x = 100 ;
System.out.println("x = " + x) ;
{ // 普通代码块
int x = 10 ; // 局部变量
System.out.println("x = " + x) ;
}
}
};
报错信息:
已在 main(java.lang.String[]) 中定义 x
int x = 10 ; // 局部变量
^
(2)普通代码块所在方法被调用后,方法中的语句顺序执行,普通代码块中的语句不会优先被执行;
2、构造块
在某个类中,并且在方法外使用“{}”括起来的代码称为构造块。
注意:
(1)构造块总是优先于构造方法执行,不管两者的位置上下关系如何;
(2)而且每一个实例化对象产生时,都会自动调用构造块,会重复调用多次。
(3)定义构造块的位置为在某个类中,但在所有方法外,因为如果在某个方法内,就成了普通代码块了。
例如:
class Demo{
private int i;
public Demo(){
System.out.println("构造方法。") ;
}
public Demo(int i){
System.out.println("构造方法。"+i) ;
}
{ // 构造块
System.out.println("构造块") ;
}
};
public class Test3{
public static void main(String args[]){
new Demo() ;
new Demo(2) ;
new Demo() ;
}
};
3、静态块
在类中并且在方法外使用static声明的代码块称为静态代码块。
(1)定义静态块必须加static关键字,否则为构造块;
(2)定义静态块的位置必须是在类中,但在所有方法外,如果在方法内会报错;
例如:
public class Test3{
public static void main(String args[]){
static{
System.out.println("主方法中的静态块");
}
}
};
报错信息:
非法的表达式开始
static{
^
(3)主类中的静态块优先于主方法执行,其他类中静态块在实例化对象的时候自动被执行,并且优先于构造块执行,不管有多少个对象产生,静态块只执行一次。
class Demo{
{ // 构造块
System.out.println("构造块") ;
}
public Demo(){
System.out.println("构造方法。") ;
}
static{ // 静态块
System.out.println("静态代码块") ;
}
};
public class Test3{
public static void main(String args[]){
System.out.println("-------------------------") ;
new Demo() ;
new Demo() ;
}
static{
System.out.println("\n\n在主类中定义的静态块") ;
}
};
运行结果:
在主类中定义的静态块
-------------------------
静态代码块
构造块
构造方法。
构造块
构造方法。
构造块
构造方法。
E 1、内部类的概念
内部类即表示在一个类的定义中包含了另一个类的定义;
2、内部类的定义格式
(1)在类中定义内部类
缺点:①打破了常规类的定义格式(类中只有属性和方法);
②增加了外部类的负担;
优点:在内部类中可以直接访问外部类中的私有成员;
(2)在方法中定义内部类
同样,优点在于在内部类中可以直接访问外部类中的私有成员;
但是需要注意的一点:
在定义内部类的方法中需要带参数,或者需要定义变量,则必须带final修饰符;
例如:
class Outer{
private String info = "Hello World!!!" ;
public void fun(int temp){ // 方法中的参数
String flag = "MLDN" ; // 方法中的变量
class Inner{ // 在方法中定义内部类
public void print(){
System.out.println("temp = " + temp) ;
System.out.println("flag = " + flag) ;
System.out.println("info = " + info) ;
}
};
new Inner().print() ;
}
};
public class Test3{
public static void main(String arg[]){
new Outer().fun(30) ;
}
};
报错信息:
从内部类中访问局部变量 temp;需要被声明为最终类型
System.out.println("temp = " + temp) ;
^
从内部类中访问局部变量 flag;需要被声明为最终类型
System.out.println("flag = " + flag) ;
^
修改代码:
class Outer{
private String info = "Hello World!!!" ;
public void fun(final int temp){ // 方法中的参数
final String flag = "MLDN" ; // 方法中的变量
class Inner{ // 在方法中定义内部类
public void print(){
System.out.println("temp = " + temp) ;
System.out.println("flag = " + flag) ;
System.out.println("info = " + info) ;
}
};
new Inner().print() ;
}
};
public class Test3{
public static void main(String arg[]){
new Outer().fun(30) ;
}
};
3、实例化内部对象
(1)在外部要实例化内部类的对象,必须先实例化外部类对象,然后通过外部类的实例化对象去实例化内部类的对象;
例如:
class Outer{
private String info = "Hello World!!!" ;
class Inner{ // 内部类
public void print(){
System.out.println(info) ;
}
};
};
public class InnerClassDemo03{
public static void main(String arg[]){
Outer out = new Outer() ; // 产生外部类实例
Outer.Inner in = null ; // 声明内部类对象
in = out.new Inner() ; // 实例化内部类对象
in.print() ;
}
};
(2)如果想要在外部直接实例化内部类,而不通过外部类的实例化对象,则可以把内部类声明为static;
注意:
①使用static声明的内部类就成为外部类,可以不通过外部类的实例化对象直接实例化内部类的对象;
例如:
class Outer{
private static String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
public void print(){
System.out.println(info) ;
}
};
};
public class InnerClassDemo06{
public static void main(String arg[]){
Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
in.print() ;
}
};
②当把内部类声明为static类之后,在内部类中如果要直接访问外部类的属性和方法,则只能访问外部类中也标记为static的属性和方法,否则编译通不过;
例如:
class Outer{
private String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
public void print(){
System.out.println(info) ;
}
};
};
public class Test3{
public static void main(String arg[]){
Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
in.print() ;
}
};
报错信息:
无法从静态上下文中引用非静态 变量 info
System.out.println(info) ;
^
修改方法:
class Outer{
private static String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
public void print(){
System.out.println(info) ;
}
};
};
public class Test3{
public static void main(String arg[]){
Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
in.print() ;
}
};
③当内部类被声明为static之后,并不表示内部类中的非static方法自动转换成static级别的了,虽然其只能访问外部类中标记为static的属性和方法,他仍然可以访问内部类中的非static的属性和方法;
例如:
class Outer{
private static String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
public void print(){
System.out.println(info) ;
}
};
};
public class Test3{
public static void main(String arg[]){
Outer.Inner.print();
}
};
报错信息:
无法从静态上下文中引用非静态 方法 print()
Outer.Inner.print();
^
例如:
class Outer{
private static String info = "Hello World!!!" ;
static class Inner{ // 使用static声明内部类,成为外部类
private int i=10; //内部类中的非static的属性
public void print(){
System.out.println(info+i) ; //可以访问内部类中的非static的属性
}
};
};
public class Test3{
public static void main(String arg[]){
Outer.Inner in = new Outer.Inner() ; // 实例化内部类对象
in.print() ;
}
};
项目案例:
A 1.使用运行时参数的形式完成一个简单的登陆程序:
例如:输入:java LoginDemo 用户名 密码
假设,用户名是abc,密码是123,如果正确则显示登陆成功,否则显示登陆失败。
本题目要求合理的考虑类的划分
个人收获:
学会了利用main()方法的参数利用
案例名称:
B 2、给出以下的操作代码,可以在Single类中增加任意的代码,只要可以在主方法处调用里面的打印方法即可。
class Single {
private Single(){}
public void print(){
System.out.println("Hello World!!!") ;
}
};
public class SingleDemo{
public static void main(String args[]){}
};
个人收获:
体会了static关键字修饰方法的作用
案例名称:
C 使用Java的引用完成以下一种代码的开发
(NODE)-->(NODE)-->(NODE )
如果此种关系表示成功之后,现在就要求完成一个可以动态增加节点的操作类,此类可以完成以下功能:
(1)增加节点,在最后增加
(2)查找节点:判断指定的节点是否存在,节点中通过节点名称判断
(3)删除节点
(4)输出全部节点
提示:可以使用内部类方便的完成。
个人收获:
把以前学过的链表(结点)的数据结构知识利用了起来;
并且再次体会了内部类的特点和作用。
今天出现的问题
A class Demo
{
static{
public static void Just1(){
System.out.println("啊啊啊啊啊啊啊啊啊啊啊啊");
}
}
{
public static void Just2(){
System.out.println("啊啊啊啊啊啊啊啊啊啊啊啊");
}
}
public void print(){
{
public static void Just3(){
System.out.println("啊啊啊啊啊啊啊啊啊啊啊啊");
}
}
}
}
解决方法:
得出结论:在普通代码块、构造块、静态块中都不能定义方法
在做题的时候发现,自己不能灵活的运用所学的知识。对于所讲的知识点基本能掌握,也似乎都理解,只是运用起来总感觉隔着一层膜,不是那么透彻,特别是this,内部类这几个地方,有些模糊。还需要加强代码的练习,培养感觉。
现在我把每天的日志编写当成了整理笔记和复习当天所学的知识,并且整理自己对知识点的理解和归纳总结。这样既可以对一天所学的知识有个整体的印象,也加深了记忆。
每天晚上睡觉之前,基本都会简单回忆一遍一天所学的新概念及应该注意的地方。
今天做作业第三题的时候,慢慢开始体会面向对象编程的特点和思路。虽然还不是恨透,不过有点感觉了。
发表评论
-
本小姐回来啦 —— 超级感谢MLDN
2009-08-10 13:24 1600我又回来了!哈哈,报告一个好消息,我已经成功入职博彦科 ... -
现在开始积极的找工作
2009-07-05 19:13 1174学习差不多了,得赶在毕业前找到一个工作啊,本小姐这段时 ... -
素质教育 —— 模拟面试
2009-06-30 19:10 1043今天一天都安排了职业素质的培养,包括简历的指导、技术面 ... -
EJB实体Bean开发的复合主键映射
2009-06-29 21:36 1685复合主键的映射:在Hibernate中是通过一个主键类来完成复 ... -
EJB实体Bean开发
2009-06-29 21:33 988EJB实体Bean开发的数据库连接采用数据源连接池的方式,因此 ... -
EJB3.0
2009-06-28 14:14 1228EJB是SUN公司提出的开发 ... -
JBoss服务器配置
2009-06-25 21:21 2079哦,哦,哦,EJB的准备课程啊。 这里开发使用的是 JB ... -
Spring结合iBATIS进行开发
2009-06-25 21:19 960使用Spring管理iBATIS完全可以参照Spring+Hi ... -
ibatis开发框架
2009-06-25 21:17 1254iBATIS为一个ORMapping框架,可以帮助开发人员完成 ... -
WebService分布式开发
2009-06-24 22:23 1904WebService:用来跨语言传递数据。 数据交互是通过XM ... -
北京下雨了
2009-06-18 19:56 771上次在公交车上,听到电视里放《北京下雨了》,那么北京今天 ... -
JQuery
2009-06-10 21:03 12581、JQuery的基本语法 ... -
AJAX中使用JSON
2009-06-10 21:02 1301在Java开发中,如果要使用JSON进行开发,需要一些支持,这 ... -
AJAX框架 —— JSON基本知识
2009-06-10 21:01 941我真想知道这年头到底有多少种框架。 1、JSON ... -
还应该多帮助同学,才能让自己进步快
2009-06-08 21:57 986今天对于本小姐来讲还真是相对轻松的一天啊,上周完成了任 ... -
业务、业务、业务。。。
2009-06-03 18:41 1142项目就是业务,项目中都是业务,技术就这么点东西,只要把 ... -
IBM Project 继续中ing....
2009-06-02 19:08 872项目就是要坚持的做下去,而且要想到做到最好,虽然框架很好 ... -
实际开发了
2009-06-01 18:17 877今天开始新的项目了,项目老师帮我们搭建好了SVN服务器, ... -
web学习笔记 —— 数据源
2009-05-31 19:56 1019使用数据源可以提升数据库的操作性能,当然,不管使用与否,对于程 ... -
SSH(Spring + Struts + Hibernate)
2009-05-31 19:47 2488Spring结合Hibernate ...
相关推荐
本教程“MLDN魔乐JAVA_03面向对象(基础)”旨在帮助初学者理解和掌握OOP的基本概念、原则以及在Java中的实现。 1. **对象与类**: - 对象:在现实世界中,万物皆可抽象为对象,对象是具有属性(数据成员)和行为...
李兴华的作品“MLDN魔乐JAVA_41面向对象题目”可能包含了深入探讨这些概念的练习题和解析。 1. **类与对象**: - 类是面向对象编程的基础,它是描述一类事物的模板,包含属性(成员变量)和行为(方法)。例如,你...
3. **异常处理**:Java的异常处理机制是其强大之处,资料可能涵盖try-catch-finally结构、异常类的层次结构、自定义异常以及如何有效使用异常处理来提高程序的健壮性。 4. **集合框架**:Java集合框架是编程中不可...
虽然缺少第一天的内容,但这个笔记集合包含了从第二天到第十三天的所有关键知识点,覆盖了Java学习的基础至进阶内容。 首先,Java的基础部分是学习的重点。笔记可能涵盖了Java语言的环境搭建,包括JDK的下载与安装...
资源名称:MLDN魔乐全新JAVA核心视频课程(94集)资源目录:【】MLDN1李兴华JAVA讲座【】MLDN魔乐全新JAVA核心课堂(01-10)【】MLDN魔乐全新JAVA核心课堂(11-20)【】MLDN魔乐全新JAVA核心课堂(21-30)【】MLDN魔乐全新...
面向对象(基础).doc 面向对象(基础)_02.doc 面向对象(高级)_01.doc 面向对象(高级)_02.doc 异常的捕获及处理.doc 包及访问控制权限.doc 多线程.doc 开发工具.doc 常用类库.doc 操作.doc 类集框架.doc Java...
5. **封装、继承与多态**:这是面向对象编程的三大特性。封装隐藏了对象的内部实现,提供公共接口供外部访问;继承允许子类从父类继承属性和方法,实现代码复用;多态则确保对象在不同上下文中的行为一致。 【异常...
【第3章:Java基础程序设计】系列,如010302_【第3章:Java基础程序设计】_运算符、表达式与语句笔记.pdf和0303_【第3章:Java基础程序设计】_判断与循环语句笔记.pdf,主要介绍了JAVA的基础语法,包括变量、运算符...
本"java视频教程-MLDN"是由知名讲师李兴华精心制作,旨在为学习者提供一套全面、深入的Java学习资源。李兴华老师以其丰富的教学经验和深厚的编程功底,确保教程内容的专业性和实用性。 在本套教程中,你将学习到:...
封装是面向对象编程的三大特性之一。在Java中,我们通过访问修饰符(如public, private, protected)来控制类的属性和方法的访问权限,实现信息隐藏,保护数据不被非法访问。 3. **继承**: 继承允许一个类(子类...
MLDN 李兴华 Java Web 开发实战经典.pdf (高清版) 带有书签,清华大学出版社 第1章 JAVA WEB开发简介 1.1、WEB发展历程 1.2、企业开发架构 1.3、JAVA EE架构 1.4、JAVA EE核心设计模式 1.5、Struts开发...
- **面向对象**:封装、继承、多态是Java面向对象的三大特性。 - **异常处理**:通过try-catch-finally语句块来处理程序运行时可能出现的异常情况。 - **集合框架**:提供了一系列用于存储和操作集合数据的接口和...
MLDN Java web开发实战笔记pdf,MLDN Java web开发实战笔记pdf,MLDN Java web开发实战笔记pdf,MLDN Java web开发实战笔记pdf
本课程“MLDN魔乐JAVA_09深入引用、this关键字、对象比较”将带你深入探讨这些核心概念。 首先,让我们来讨论“引用”。在Java中,变量可以分为基本类型和引用类型。引用类型变量实际上存储的是对象在内存中的地址...
资源名称:MLDN李兴华JAVA WEB视频教程(30集)资源目录:【】MLDN软件实训练中心—JAVA.WEB教程.19_使用JSP.DAO完成用户登陆【】MLDN软件实训练中心—JAVA.WEB教程.1_Tomcat服务器配置【】MLDN软件实训练中心—JAVA...
李兴华 MLDN Java开发实战经典 java常用类库 CHM
封装是面向对象编程的三大特性之一,它通过访问控制修饰符(如`public`, `private`, `protected`)来限制对类成员的访问,保护数据的安全。继承允许子类继承父类的属性和方法,提高了代码的复用性。多态则允许不同的...
MLDN 李新华 老师 Java Web基础篇课后习题答案,Java Web高级案例篇全部源码。...第三章.XML简介:1,2,3题 第五章.JSP基础语法:1,2题 第六章.JSP内置对象:1,2,3,4,5,6题+系统整合 第七章.JavaBean:1,2,3,4,5,6题
《MLDN 2009 JAVA SE 笔记16-23》是MLDN(铭隆动力网络)教育机构的李兴华老师在2009年针对Java Standard Edition进行深入讲解的一份珍贵的学习资料,涵盖了从第16课到第23课的核心知识点。这些笔记对于学习和理解...