本文共 3920 字，大约阅读时间需要 13 分钟。
构造方法：
1：声明时候不调用构造方法
class Person
结果如下：
F:\test>javac test07.java
F:\test>java test07
构造方法
2：
在整个java操作中，如果一个类中没有明确的声明一个构造方法，则会自动生成一个无参数的什么都不做的构造方法，供用户使用。
class Person
{
public Person(){
}
}
构造方法的主要作用是为类中的属性初始化，既然是方法，则方法中肯定可以传递参数。
此时定义一个构造，同时传递参数
class Person{
private String name;
private int age;
public Person(String n,int a){
this.setName(n);
this.setAge(a);
}
public void setName(String n){
name = n;
}
public void setAge( int a){
if(a>=0&&a<=150){
age = a;
}
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public void tell(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
public class test07
{
public static void main(String args[]){
Person per = null;//声明对象
per = new Person("张三",30);
per.tell();
}
}
结果为：
F:\test>javac test07.java
F:\test>java test07
姓名:张三 年龄:30
4：构造方法的重载
class Person{class Person{
private String name;
private int age;
public Person(){}
public Person(String n,int a){
this.setName(n);
this.setAge(a);
}
public void setName(String n){
name = n;
}
public void setAge( int a){
if(a>=0&&a<=150){
age = a;
}
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public void tell(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
public class test07
{
public static void main(String args[]){
//Person per = null;//声明对象
new Person("张三",30).tell();
//per.tell();
}
}
所谓的匿名对象只是在堆内存中开辟空间，而不存在栈内存的引用。。。
public class test07内部类：
1.1 什么是内部类？ # 一个类的内部还有类，就成为内部类。如果在类outer的内部再定义一个类inner，此时类inner就称为内部类，而类outer则称为外部类。# 内部类可以声明为public或private，此时对其访问的限制于成员变量和方法完全相同。
1.2 内部类的定义格式
标示符 class 外部类的名称{
[java]
class Outer
{
private String info="hello,word!";
class Inner
{
public void print(){
System.out.println(info);
}
};
public void fun(){
new Inner().print();
}
};
public class Inner01
{
public static void main(String args[]){
new Outer().fun();
}
}
F:\java>javac Inner01.java
F:\java>java Inner01
hello,word!
1.3：内部类的缺点：
1：正常的一个类操作时，在类中最好只定义属性或方法。如果定义一个类的话，就破坏了程序的一个结构。
优点：
将以上的两个类变成两个独立的类，在分析：
[java]
class Outer
{
private String info="hello,word!";
public void fun(){
new Inner().print();
}
public String getInfo(){
return this.info;
}
};
class Inner
{
public void print(){
System.out.println(new Outer().getInfo());
}
};
public class Inner01
{
public static void main(String args[]){
new Outer().fun();
}
}
以上程序实例了两个Outer对象，显然不合适：
可以这样改：
[java]
class Outer
{
private String info="hello,word!";
public void fun(){
new Inner(this).print();
}
public String getInfo(){
return this.info;
}
};
class Inner
{
private Outer out=null;
public Inner(Outer out){
this.out=out;
}
public void print(){
System.out.println(new Outer().getInfo());
}
};
public class Inner01
{
public static void main(String args[]){
new Outer().fun();
}
}
F:\java>java Inner01
hello,word!
:1.4：
如果内部类拿到外部以后，会发现代码增加了，而且复杂度也增加了，使用内部类的最大优点：可以方便访问外部类中的私有属性。
但是以上的内部类是无法在外部直接使用的，
1.5：使用static声明内部类
如果一个内部类使用static关键字声明，则此内部类就成为外部类，可以直接通过外部类进行访问。本文转自 风雨萧条 博客，原文链接： http://blog.51cto.com/1095221645/1427052 如需转载请自行联系原作者