Java笔记9：构造方法，内部类

构造方法：

1：
#构造方法的名称必须与类名一样。
#构造方法的声明处不能有任何返回值类型的声明。
#不能在构造方法中使用人turn返回一个值

实例化对象时候调用构造方法

声明时候不调用构造方法

class Person
{
 public Person(){
  System.out.print("构造方法");
 }
}
public class test07
{
 public static void main(String args[]){
   Person per = null;//声明对象
   per = new Person();
 }
}

结果如下：

F:\test>javac test07.java

F:\test>java test07
构造方法

2：

在整个java操作中，如果一个类中没有明确的声明一个构造方法，则会自动生成一个无参数的什么都不做的构造方法，供用户使用。

class Person
{
 public Person(){
  
 }
}

3：

构造方法的主要作用是为类中的属性初始化，既然是方法，则方法中肯定可以传递参数。

此时定义一个构造，同时传递参数

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{
   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;//声明对象
   per = new Person("张三",30);
   per.tell();
 }
}

5：匿名对象：

在java中如果一个对象只是使用一次，则就可以将其定义为匿名对象、

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
{
 public static void main(String args[]){
   //Person per = null;//声明对象
   new Person("张三",30).tell();
   //per.tell();
 }
}

内部类：

1.1 什么是内部类？

#  一个类的内部还有类，就成为内部类。如果在类outer的内部再定义一个类inner，此时类inner就称为内部类，而类outer则称为外部类。

#  内部类可以声明为public或private，此时对其访问的限制于成员变量和方法完全相同。

1.2   内部类的定义格式

标示符 class 外部类的名称{
//外部类的成员
标示符 class 内部类的名称
{
//内部类的成员
}
}

[java] view plaincopyprint?

1. class Outer  

2. {  

3.  private String info="hello,word!";  

4.  class Inner  

5.  {  

6.   public void print(){  

7.   System.out.println(info);  

8.   }  

9.     

10.  };  

11.  public void fun(){  

12.  new Inner().print();  

13.  }  

14. };  

15. public class Inner01  

16. {  

17.  public static void main(String args[]){  

18.  new Outer().fun();  

19.  }  

20. }  

结果为：

F:\java>javac Inner01.java

F:\java>java Inner01
hello,word!

1.3：内部类的缺点：

1：正常的一个类操作时，在类中最好只定义属性或方法。如果定义一个类的话，就破坏了程序的一个结构。

优点：

将以上的两个类变成两个独立的类，在分析：

[java] view plaincopyprint?

1. class Outer  

2. {  

3.  private String info="hello,word!";  

4.    

5.  public void fun(){  

6.  new Inner().print();  

7.  }  

8.  public String getInfo(){  

9.  return this.info;  

10.  }  

11. };  

12. class Inner  

13.  {  

14.   public void print(){  

15.   System.out.println(new Outer().getInfo());  

16.   }  

17.     

18.  };  

19. public class Inner01  

20. {  

21.  public static void main(String args[]){  

22.  new Outer().fun();  

23.  }  

24. }  

以上程序实例了两个Outer对象，显然不合适：

可以这样改：

[java] view plaincopyprint?

1. class Outer  

2. {  

3.  private String info="hello,word!";  

4.    

5.  public void fun(){  

6.  new Inner(this).print();  

7.  }  

8.  public String getInfo(){  

9.  return this.info;  

10.  }  

11. };  

12. class Inner  

13.  {  

14.   private Outer out=null;  

15.   public Inner(Outer out){  

16.   this.out=out;  

17.   }  

18.   public void print(){  

19.   System.out.println(new Outer().getInfo());  

20.   }  

21.     

22.  };  

23. public class Inner01  

24. {  

25.  public static void main(String args[]){  

26.  new Outer().fun();  

27.  }  

28. }  

结果为：

F:\java>javac Inner01.java

F:\java>java Inner01
hello,word!

:1.4：

如果内部类拿到外部以后，会发现代码增加了，而且复杂度也增加了，使用内部类的最大优点：可以方便访问外部类中的私有属性。

但是以上的内部类是无法在外部直接使用的，

1.5：使用static声明内部类

如果一个内部类使用static关键字声明，则此内部类就成为外部类，可以直接通过外部类进行访问。

本文转自    风雨萧条 博客，原文链接：  http://blog.51cto.com/1095221645/1427052      如需转载请自行联系原作者