System.out.print（arg[i]+"、"）;
}
}
};
publicstaticvoidfun（int...arg）{//可变参数
for（intx:
arg）{//使用foreach输出输出
System.out.print（x+"、"）;
}
classPerson{
Stringname;//声明姓名属性
intage;//声明年龄属性
publicvoidtell（）{//取得信息
System.out.println（"姓名：
"+name+"，年龄：
"+age）;
}
Personper=newPerson（）;
per.name=”张三”;
per.age=30;
per.tell（）;
classPerson{
privateStringname;//声明姓名属性
privateintage;//声明年龄属性
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetName（）{
returnname;
}
publicvoidsetAge（intage）{
this.age=age;
}
publicintgetAge（）{
returnage;
}
publicvoidtell（）{
System.out.println（"姓名：
"+name+"，年龄：
"+age）;
}
};
publicclasstext{
publicstaticvoidmain（Stringarsgh[]）{
Personper=newPerson（）;//声明并实例化对象
per.setName（"张三"）;//为name属性赋值
per.setAge（30）;//为age属性赋值
per.tell（）;
}
};
newPerson（“张三”,30）.tell（）;//匿名对象
publicStudent（Strings,Stringn,floatm,floate,floatc）{
this.setStuno（s）;
this.setName（n）;
this.setMath（m）;
this.setEnglish（e）;
this.setComputer（c）;
}、、构造方法
Studentstu=null;//声明对象
stu=newStudent（"MLDN-33","李兴华",95.0f,89.0f,96.0f）；//调用构造方法初始化对象
Stringname=newString（"LiXingHua"）;//实例化String对象
System.out.println（"姓名：
"+name）;
Stringname="LiXingHua";//实例化String对象
System.out.println（"姓名：
"+name）;
两种方法，一般用直接赋值的方式。
这样可节省内存空间
Stringstr1="hello";//直接赋值
Stringstr2=newString（"hello"）;//通过new赋值
Stringstr3=str2;//传递引用
System.out.println（"str1==str2-->"+（str1==str2））;//false
System.out.println（"str1==str3-->"+（str1==str3））;//false
System.out.println（"str2==str3-->"+（str2==str3））;//true
System.out.println（"str1equalsstr2-->"+（str1.equals（str2）））;//true
System.out.println（"str1equalsstr3-->"+（str1.equals（str3）））;//true
System.out.println（"str2equalsstr3-->"+（str2.equals（str3）））;//true
staticStringcountry="A城";//定义城市属性，有默认值，static
p1.country="B城";//修改static属性
publicstaticvoidsetCountry（Stringc）{//此方法可以直接由类名称调用
country=c;
}
Person.setCountry（"B城"）;//调用静态方法修改static属性的内容
classPerson{//定义Person类
privatestaticStringcountry="A城";//定义静态属性
privateStringname="Hello";
publicstaticvoidsFun（Stringc）{
System.out.println（"name="+name）;//错误，不能调用非static属性
fun（）;//错误，不能调用非static方法
}
publicvoidfun（）{
System.out.println（"World"）;
}
};
classDemo{
{//直接在类中编写代码块，称为构造块
System.out.println（"1、构造块。
"）;
}
static{//使用static，称为静态代码块
System.out.println（"0、静态代码块"）;
}
publicDemo（）{//定义构造方法
System.out.println（"2、构造方法。
"）;
}
};
publicclasstext{
static{//在主方法所在的类中定义静态块
System.out.println（"在主方法所在类中定义的代码块"）;
}
publicstaticvoidmain（Stringargs[]）{
newDemo（）;//实例化对象
newDemo（）;//实例化对象
newDemo（）;//实例化对象
}
};结果：
0、静态代码块
1、构造块。
2、构造方法。
1、构造块。
2、构造方法。
1、构造块。
2、构造方法。
classSingleton{
privateSingleton（）{//将构造方法进行了封装，私有化
}
publicvoidprint（）{
System.out.println（"HelloWorld!
!
!
"）;
}
};
publicclassSingletonDemo02{
publicstaticvoidmain（Stringargs[]）{
Singletons1=null;//声明对象
s1=newSingleton（）;//错误，无法实例化对象
}
};
classSingleton{
privatestaticSingletoninstance=newSingleton（）;//在内部产生本类的实例化对象
publicstaticSingletongetInstance（）{//通过静态方法取得instance对象
returninstance;
}
privateSingleton（）{//将构造方法进行了封装，私有化
}
publicvoidprint（）{
System.out.println（"HelloWorld!
!
!
"）;
}
};
publicclassSingletonDemo05{
publicstaticvoidmain（Stringargs[]）{
Singletons1=null;//声明对象
Singletons2=null;//声明对象
Singletons3=null;//声明对象
s1=Singleton.getInstance（）;//取得实例化对象
s2=Singleton.getInstance（）;//取得实例化对象
s3=Singleton.getInstance（）;//取得实例化对象
s1.print（）;//调用方法
s2.print（）;//调用方法
s3.print（）;//调用方法
}
};
//类名称数组名称[]=new类名称[长度]
Personper[]=newPerson[3];//开辟了三个空间大小的对象数组
Personper[]={newPerson（"张三"）,newPerson（"李四"）,newPerson（"王五"）};
classOuter{//定义外部类
privatestaticStringinfo="helloworld";//定义外部类的私有属性
staticclassInner{//使用static定义内部类为外部类
publicvoidprint（）{//定义内部类的方法
System.out.println（info）;//直接访问外部类的私有属性
}
};
publicvoidfun（）{//定义外部类的方法
newInner（）.print（）;//通过内部类的实例化对象调用方法
}
};
publicclassInnerClassDemo03{
publicstaticvoidmain（Stringargs[]）{
newOuter.Inner（）.print（）;//调用外部类的fun（）方法
}
};
classOuter{//定义外部类
privateStringinfo="helloworld";//定义外部类的私有属性
classInner{//定义内部类
publicvoidprint（）{//定义内部类的方法
System.out.println（info）;//直接访问外部类的私有属性
}
};
publicvoidfun（）{//定义外部类的方法
newInner（）.print（）;//通过内部类的实例化对象调用方法
}
};
publicclassInnerClassDemo04{
publicstaticvoidmain（Stringargs[]）{
Outerout=newOuter（）;//外部类实例化对象
Outer.Innerin=out.newInner（）;//实例化内部类对象
in.print（）;//调用内部类的方法
}
};
classOuter{//定义外部类
privateStringinfo="helloworld";//定义外部类的私有属性
publicvoidfun（finalinttemp）{//定义外部类的方法
classInner{//在方法中定义的内部类
publicvoidprint（）{//定义内部类的方法
System.out.println（"类中的属性：
"+info）;//直接访问外部类的私有属性
System.out.println（"方法中的参数：
"+temp）;
}
};
newInner（）.print（）;//通过内部类的实例化对象调用方法
}
};
publicclasstext{
publicstaticvoidmain（Stringargs[]）{
newOuter（）.fun（30）;//调用外部类的方法
}
};
classA{
};
classB{
};
classCextendsA,B{//错误，同时继承了两个父类
};
interfaceA{//定义接口A
publicstaticfinalStringAUTHOR="李兴华";//全局常量
publicabstractvoidprint（）;//抽象方法
publicabstractStringgetInfo（）;//抽象方法
}
interfaceB{//定义接口B
publicvoidsay（）;//定义抽象方法
}
classXextendsBimplementsA{//X类线继承B类，再实现A接口
classA{//定义类A
publicvoidfun1（）{//定义fun1（）方法
System.out.println（"A-->publicvoidfun1（）{}"）;
}
publicvoidfun2（）{
this.fun1（）;//调用fun1（）方法
}
};
clas
升级会员 