学完第五天，有点混。请教一下一般函数，构造函数，成员变量的调用格式都是什么样的，记来记去脑子越来越混了。最好有个简单的例子~后面我没学到的不用提了，不然更混，谢谢大家~


说实话，大家讲的我真的没怎么明白，有的代码我也放进去去运行一下看看结果，结果各种报错，里面的错误提示我都没见过。。。想改也改不了。所以有明白我问什么的同学帮我解答一下一般函数的调用问题就好了，别说的太深奥了，本来我就不懂，结果更糊涂了。。。

一般函数的调用为什么有时候是  函数名（参数）；有时候是 对象名.函数名（参数）；？

例如day5那天构造函数这讲里的代码（标注红色的两次函数调用）：

class Person
{
        private String name;
        private int age;
        
        {
                //System.out.println("person code run");
                cry();
        }

        Person()
        {
                System.out.println("A: name="+name+",,age="+age);
               
        }
        /**/
        Person(String n)
        {
                name = n;
                System.out.println("B: name="+name+",,age="+age);

                //cry();
               
        }
        /*
        public void setName(String n)
        {
                name  = n;
        }
        public String getName()
        {
                return name;
        }
        */
        Person(String n,int a)
        {
                name = n;
                age = a;
                System.out.println("C: name="+name+",,age="+age);
                //cry();
        }

        public void cry()
        {
               
                System.out.println("cry......");
        }
}

class  PersonDemo2
{
        public static void main(String[] args)
        {
                Person p1 = new Person();
                p1.cry();
               

                Person p2 = new Person("lisi");
        
                //System.out.println(p2.getName());

                //Person p3 = new Person("wnagu",10);
        
               
        }
}

占沙发！！！！！

首先说一下各自的特点，特点一一般函数有返回值，而构造函数没有返回值，例如：Person类中  如果函数写成Person（）{}则为构造函数，而void Person（）{}则为一般函数，但是一般函数的方法名通常小写，
特点二构造函数时用来初始化的，是随着类的加载而加载的，也就是说只要你主函数中出现了类名的引用就会加载构造函数中的内容，
类中呢有成员，成员呢非为成员变量和成员函数，他们都是通过对象的建立而出现的，如：你想调用Person类中的成员，需要建立Person类的对象Person p=new Person()，然后    P.成员名   实现调用，

刘明月 发表于 2012-9-14 14:11
首先说一下各自的特点，特点一一般函数有返回值，而构造函数没有返回值，例如：Person类中  如果函数写成Pe ...

可不可以这样理解
一般函数的调用：函数名（参数）；
成员变量的调用：对象名.成员变量；
构造函数的调用：构造函数名 对象=new 构造函数（）；

在写，==

刘 佳 发表于 2012-9-14 14:16
可不可以这样理解
一般函数的调用：函数名（参数）；
成员变量的调用：对象名.成员变量；

一般函数是    对象名.函数名
成员调用      对象名.成员变量名
构造函数不需要调用，只要你主函数出现了该类的引用就会加载构造函数里边的东西，你在构造函数里边写点输出语句好好体会一下

范泰洋 发表于 2012-9-14 14:18
在写，==

package Tolls;
//请教一下一般函数，构造函数，成员变量的调用格式都是什么样的，记来记去脑子越来越混了。最好有个简单的例子~后面我没学到的不用提了，不然更混，谢谢大家~

class Sun{
        private String s;//成员变量
        private int x;//成员变量
        Sun(){//空参数的构造函数；
                System.out.println("zero");
        }
        Sun(String s){//带一个参数的构造函数
                this.s = s;
                System.out.println(s);
        }
        Sun(String s,int x){//带2个参数的构造函数
                this.s = s;
                this.x = x;
                System.out.println(s+x);
        }
       
        public void method(){//成员函数。
                System.out.println("run method.");
        }
       
        public String method(String s){
                return s;
        }
       
}

public class HanshuTest {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                //Sun s = new Sun();//这个是空参数对象，会去找到相对应的构造器给对象进行初始化。下面的是分别带了一个和二个实际参数的对象，会分别去找湘对应的！
                //Sun s = new Sun("lisi");
                Sun s = new Sun("lis",20);
                s.method();
                String st = s.method("haha");
                System.out.println(st);
        }

}
/*构造函数：对象就会调用与之对应的构造函数。
作用：可以用于给对象进行初始化。
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
细节：当自己定义了一个构造好函数，那么默认的构造函数就没有了。
构造函数的名字是和类名一样的，不需要返回值，是给对象初始化话的！
一般函数一般定义在成员位置上，叫做成员函数。
这个函数可以有返回值也可以没有返回值。
这个调用是创建了对象之后，用引用型变量调用，也可以定义在主函数中，直接写成method（），这样也可以的！

* */

刘明月 发表于 2012-9-14 14:20
一般函数是    对象名.函数名
成员调用      对象名.成员变量名
构造函数不需要调用，只要你主函数出现了 ...

一般函数的调用为什么有时候是  函数名（参数）；有时候是 对象名.函数名（参数）；？

例如day5那天构造函数这讲里的代码（标注红色的两次函数调用）：

class Person
{
        private String name;
        private int age;
       
        {
                //System.out.println("person code run");
                cry();
        }

        Person()
        {
                System.out.println("A: name="+name+",,age="+age);
               
        }
        /**/
        Person(String n)
        {
                name = n;
                System.out.println("B: name="+name+",,age="+age);

                //cry();
               
        }
        /*
        public void setName(String n)
        {
                name  = n;
        }
        public String getName()
        {
                return name;
        }
        */
        Person(String n,int a)
        {
                name = n;
                age = a;
                System.out.println("C: name="+name+",,age="+age);
                //cry();
        }

        public void cry()
        {
               
                System.out.println("cry......");
        }
}

class  PersonDemo2
{
        public static void main(String[] args)
        {
                Person p1 = new Person();
                p1.cry();
               

                Person p2 = new Person("lisi");
       
                //System.out.println(p2.getName());

                //Person p3 = new Person("wnagu",10);
       
               
        }
}

class Person
{
        private String name;
        private int age;
      
        {
                //System.out.println("person code run");
                cry();
        }

        Person()
        {
                System.out.println("A: name="+name+",,age="+age);
               
        }
        /**/
        Person(String n)
        {
                name = n;
                System.out.println("B: name="+name+",,age="+age);

                //cry();
               
        }
        /*
        public void setName(String n)
        {
                name  = n;
        }
        public String getName()
        {
                return name;
        }
        */
        Person(String n,int a)
        {
                name = n;
                age = a;
                System.out.println("C: name="+name+",,age="+age);
                //cry();
        }

        public void cry()
        {
               
                System.out.println("cry......");
        }
}

class  PersonDemo2
{
        public static void main(String[] args)
        {
                Person p1 = new Person();
                p1.cry();
               

                Person p2 = new Person("lisi");
      
                //System.out.println(p2.getName());

                //Person p3 = new Person("wnagu",10);
      
               
        }
}
因为你的那个cry（）在person类中，是可以在方法中调用方法的，而下面为什么是p1.cry（）是创建了对象，用对象的一个引用去调用方法！

我用代码的形式给你解释一下哈，如有解释不对的地方，请同学见谅哦：
一般函数：
staticvoid print()
{
  System.out.println("HAHA");
}
这期间加上一些修饰都是可以的，比如public公有，private私有，static静态等等
void是代表没有返回值类型的一种函数
而像有返回值类型的：比如int型啊，char型啊，double型，类类型啊，都是可以的，根据要求而定
这些统统都可以成为一般函数。

构造函数就不一样了，是针对类而言的，一个类中存在着默认构造函数和自定义构造函数：
默认构造函数：
class Person
{
    //Person(){}  //这个就是默认空构造函数
    private String name;
      private int age;
      Person()
      {
            System.out.println("HAHA");
      }
      Person(String n)
      {
              name = n;
             System.out.print("name="+name);
      }
      Person(String n, int a)
      {
              name = n;
              age = a;
              System.out.println("name="+name+"...age="+age);
       }
      public  static void print()
      {
           System.out.println("HAHA");
      }

}
空构造函数下面的Person()、Person(String n)、Person(String n,int a )这些就都是自定义构造函数了，只是对构造函数进行了重载
成员变量就是上面的 private String name;   
                             private int age;
成员变量 是定义在整个类中，在整个类中都可以被访问
而局部变量是定义在语句和函数中的

像一般函数在调用的时候用对象调用和类名调用都是可以的，只不过类名调用要有static修饰
Person.print();//这是一般函数的调用
构造函数的调用是在对象一建立的时候，因为构造函数是给对象初始化用的，对象一建立，就会直接调用构造函数，调用的时候写的参数类型和参数个数要与之对应
Person p = new Person("zhangsan",23); //这个是构造函数的调用  
成员变量的调用是看有没有被private修饰，如果修饰了只有本类可以访问，其他类不能访问，如果没有private修饰的话其他类也是可以访问的，调用的时候也是建立在对象的基础上
Person a = new Person();
a.name = "zhangsan";//这个就是成员变量的调用，前提没有private修饰

以上是我的理解，希望对你有帮助。

那通俗点儿说呢:

构造函数:
  1.构造函数跟该函数所在的类同名,大小写也必须一致
    例:类名为class Demo(){}
    那么它内部的构造函数名就是Demo(){} //当然,小括号内可以加入参数 例如: Demo(String name){}
  2,构造函数没有返回值
    (延用上面的例子)也就是说类中的构造函数前面不可以写返回值类型 例如不能这样写: String Demo(){}(注意,作为构造函数,是  不  能这样写的)
  3,构造函数的生命周期
    它的存活时间是在类被加载的时候就随之存在的,根据这个特点,我们通常把构造函数用个给这个类初始化
    例如:
      class Demo()
      {
        private String nameInClass
        Demo(String name)
          {
            this.nameInClass = name;//将传入的值赋值给这个类中的私有变量nameInClass
          }
      }
   4.构造函数的加载
      当我们建立这个类的对像或其子类的时候会默认加载这个构造函数,即使我们没有写

成员变量:
静态成员变量是被static修饰的变量,这类变量的生命周期同构造函数一样
另一种变量在使用的时候,必须要建立这个变量所在类的对象
成员变量的调用如下例:
class Demo()
{
String normalVal = "normal";
static String staticVal = "static";
}
调用静态变量
Demo.staticVal;
调用普通变量
Demo test = new Demo();
test.normalVal;

一般函数
1,格式以主函数为例
public static void main(String[] args)
public static 限定main函数调用者的权限或者说是main函数的作用域
void main函数内部使用return关键字返回的类型
String[] 形式参数类型,也就限定是你要传入参数的类型
args 形式参数名,也就是你要传入参数的名字
2,调用
同一个类中平级函数间的调用
例:
class Demo()
{
void function1(String str)
{
  System.out.println(str);
}
String function2(String str)
{
  return str;
}
public satic void main(String[] args)
{
  function1("what's up?!");
  String str = "take it easy.";
  System.out.println(function2(str));
}
}
不同类中的调用:你可能没学,就简单说一下
新建一个类对象,例用类对象的名字 . 函数名();
调用静态函数 可以直接用类名 . 函数名();//这个同静态变量的调用类似
不同包中的调用:你也没学,但是调用方法很简单,只不过在调用之前加上包名 . 就可以了

成员变量和成员函数以及构造函数都是类的组成部分。

构造函数在创建类的对象时只使用一次，成员变量和成员函数可以多次被使用。

构造函数负责初始化成员变量，可以调用成员函数。

不知这样是否满意。

一般函数的调用为什么有时候是  函数名（参数）；有时候是 对象名.函数名（参数）？
     回答：其实调用的时候都是  对象名.方法名（参数列表） 来调用方法的。   你平时用的  方法名（参数列表） 调用方法  其实在Java中会变成
               this.方法名（参数列表）   我们都省略了this引用，  this表示当前对象的引用。

构造函数的调用：当你 new 对象（参数列表） 的时候，JAVA会根据你 参数列表中 的 1.参数的个数 2.参数的类型 3.参数的顺序 来寻找对应的构造函数来初始化对象。
                            如果你的这个类存在于继承层次中，每个构造函数中的第一条语句是隐式调用超类默认构造函数或空参数构造函数，你也可以显示调用超类的其他构造函数，（利用super语句）这样会形成一个构造函数调用链，一直掉用到Object的构造函数为止。
                            本类中的构造函数利用this语句调用本类中的其他构造函数。（参数列表来识别）  注意:this引用和this语句的区别，super引用和super语句的区别！（不详细写了）


class Person
{
        private String name;
        private int age;
        
        {
                //System.out.println("person code run");
                this.cry();                                  //本类中存在的方法用this（代表当前对象的引用，这里的当前对象就是Person的对象）来调用。
                                                                //但this可以省略，JAVA会帮你自动添加。
        }

        Person()
        {
                System.out.println("A: name="+name+",,age="+age);
               
        }
        /**/
        Person(String n)
        {
                name = n;
                System.out.println("B: name="+name+",,age="+age);

                //this.cry();
               
        }
        /*
        public void setName(String n)
        {
                name  = n;
        }
        public String getName()
        {
                return name;
        }
        */
        Person(String n,int a)
        {
                name = n;
                age = a;
                System.out.println("C: name="+name+",,age="+age);
                //this.cry();
        }

        public void cry()
        {
               
                System.out.println("cry......");
        }
}

class  PersonDemo2
{
        public static void main(String[] args)
        {
                Person p1 = new Person();
                p1.cry();                     //cry()方法在Person类中，所以要创建Person的对象p1来调用。
               

                Person p2 = new Person("lisi");
        
                //System.out.println(p2.getName());

                //Person p3 = new Person("wnagu",10);
        
               
        }
}