黑马程序员技术交流社区

标题: 有参、无参 构造函数的问题 [打印本页]
作者: LINUS    时间: 2013-3-30 22:58
标题: 有参、无参 构造函数的问题
本帖最后由 LINUS 于 2013-3-30 23:47 编辑

已知Student类，属性name，age；写出这个类，要求有属性，set和get方法，无参构造函数，有参构造函数（name, age）。

这是我下面的代码。学的已经乱套了，

什么时候用getName 什么时候需要建立对象，这个问题正确格式应该是？

可以具体代码给加注释 剖析一下么？万分感谢。

class Student(){
　　String name;
　　int age;
　　public void method(){
　　this.name = name;
　　this.age = age;
　　}
　　setName(){
　　String name = "张三";
　　int age = 20;
　　
　　}
　　getName(String name , int age){
　　        return ;
　　}
}
class Demo{
        public static void main(String[] args){
          Student p = new Student();       
      p.method;
        }
}
作者: _王涛    时间: 2013-3-30 23:15
正确答案因该是：
class Student{
private String name;
private int age;

public Student() {//无参构造方法
}
public Student(String name, int age) {//有参构造方法
  this.name = name;
  this.age = age;
}
public String getName() {//得到名字的值
  return name;
}
public void setName(String name) {//设置名字
  this.name = name;
}
public int getAge() {
  return age;
}
public void setAge(int age) {
  this.age = age;
}
}
class Test
{        
        public static void main(String[] args)
        {
         Student st=new Student("king",24);//为其进行初始化赋值
         System.out.println(st.getName());//得到返回的年龄
         System.out.println(st.getAge());

}
}
希望帮到你！
         
作者: 郭沐昌    时间: 2013-3-30 23:17
我明你说的意思
本身你的代码就是错的
作者: 胡帅冰    时间: 2013-3-30 23:20
  1. package A;

  3. class demo
  4. {
  5.         public static void main(String args[])
  6.         {
  7.                 //创建对象
  8.                 student p=new student("张三",12);
  9.                 //调用对象类中的method方法
  10.                 p.method();
  11.                 //通过调用函数中getname和getage来显示姓名 年龄
  12.                 System.out.println("从主函数中调用getname和getage输出的这个人的姓名是："+p.getname()+"\t年龄是："+p.getAge());
  13.         }       
  14. }
  15. class student
  16. {
  17.         //定义私有的name age 变量。
  18.         private String name;
  19.         private int age;
  20.         //构造函数   
  21.         student (String name ,int age)
  22.         {
  23.                 this.name=name;
  24.                 this.age=age;
  25.         }
  26.         //name是私有变量，外部类不能调用，因此添加getname方法，返回name的值
  27.         public String getname()
  28.         {
  29.                 return name;
  30.         }
  31.         //同理与name
  32.         public int getAge()
  33.         {
  34.                 return age;
  35.         }
  36.         //student中的method方法，可以在对象中调用
  37.         public void method()
  38.         {
  39.                 System.out.println("method方法输出的姓名年龄："+name+"\t"+age);
  40.         }

  42.         }
复制代码
你注意两次输出的代码。
作者: 袁梦希    时间: 2013-3-30 23:23
嘿嘿 楼主比较实在，楼主的这句话挺逗“这是我下面的代码。学的已经乱套了”

闲话少说，楼主这段代码，首先涉及一个封装的概念。

面向对象的封装，就是把一个对象的属性和行为（方法）封装到一个模块（类）中，
通常是将属性私有化，在提供get和set方法来访问这些属性。这样就达到了封装的目的。当然我说的还不够全面，我说的这些是面向对象编程的基本思想。
你这个变量就是属性
可以封装成这样  
public class Student {
       
        private String name;
       
        private int age;

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
        }

}

同时还可以提供构造方法在里面    一些数值的传递我就不多说了，怕地方不够了 嘿嘿
作者: 赵喜平    时间: 2013-3-30 23:24
class StudentDemo
{
        String name;
        int age;
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getAge() {
                return age;
        }
        public void setAge(int age) {
                this.age = age;
        }  
       
}

public class Test
{
        public static void main(String args[]){
               
                StudentDemo s = new StudentDemo();
                s.setName("zhangsan");
                s.setAge(10);
                System.out.println("姓名  :"+s.name+",年龄  :"+s.age);
        }
}


感觉这个比较靠谱
作者: 黄诗宾    时间: 2013-3-30 23:25
本帖最后由 黄诗宾 于 2013-3-30 23:26 编辑

2种方法代码实现如下，学会第一种即可，第二种只需要理解：

构造函数方法：
  1. class Student
  2. {
  3.         private String name;
  4.         private int age;
  5.                
  6.         //Person(){} 无参构造函数
  7.         Student(String name, int age){ //有参构造函数.接收主函数的赋值
  8.                 this.name = name; //如果这里没有this，则该值传不出去。  
  9.                 this.age = age;//this指向本类成员变量,将值赋予了对内存里的对象.
  10.         }
  11.         public void show(){
  12.                 System.out.println(name+"..."+age);
  13.         }
  14. }   

  16. class Demo{
  17.          public static void main(String[] args){  
  18.         Student s = new Student("张三",22);//给构造函数传值
  19.         s.show();
  20.          }
  21. }
复制代码
封装get set方法：
  1. class Person  {  
  2.     private String name;  //定义成员变量name  
  3.     private int age; //定义成员变量age  
  4.     //赋值函数，标准写法(未完美) 完美的写法是用构造函数初始化，this关键字  
  5.     public void setName(String n){ //注意前面的修饰符为void,括号里为要获取的参数类型和参数  
  6.         name = n;  
  7.     }public void setAge(int a){ //获取age值，为int类型  
  8.       age = a;  
  9.     }  
  10.     //取值函数，标准写法(未完美)  
  11.     public String getName(){ //函数类型为类类型  
  12.         return name;}  
  13.     public int getAge(){ //取出name值，直接写空括号，返回函数  
  14.         return age;}   
  15.   
  16.     void speak(){//输出函数  
  17.          System.out.println(name+".."+age+"...");  
  18.     }  
  19.    
  20. }  
  21. class Demo1{  
  22.         public static void main(String[] args) {  
  23.             Person p1 = new Person(); //定义一个对象名为p1  
  24.                 p1.setAge(22); //用p1给函数传值22
  25.                                 p1.setName("zhangsan");//传名字
  26.                         p1.speak();//打印
  27.         }  
  28. }  
复制代码
作者: 王_强    时间: 2013-3-30 23:29

public class StudentDome {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub

        }

}

class Student{
        private int age;
        private String name;
       
        public int getAge() {
                return age;
        }
        public void setAge(int age) {
                this.age = age;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        //带参的构造方法
        public Student(int age, String name) {
                super();
                this.age = age;
                this.name = name;
        }
        //无参的构造方法
        public Student() {
                super();
        }
       
}
作者: 郭沐昌    时间: 2013-3-30 23:30
  1. A


  4. public class Demo {

  6.         /**
  7.          * @param args
  8.          */
  9.         public static void main(String[] args) {
  10.        
  11.                 Student p = new Student("张三",20 );        
  12.               p.method();
  13.           
  14.         }

  16. }

  18. B


  21. public class Student {
  22.         private static String name;
  23.         private static int age;
  24.         public Student(String name, int age) {
  25.        
  26.                 this.name=name;
  27.                 this.age=age;
  28.         }
  29.         public String getName() {
  30.                 return name;
  31.         }
  32.         public int getAge() {
  33.                 return age;
  34.         }
  35.         public static void method(){
  36.                 System.out.println("method方法输出的姓名："+name+"\t"+"年龄:"+age);
  37.         }

  39.        
  40.        
  41. }       
复制代码
作者: LINUS    时间: 2013-3-30 23:32
真心谢谢你们了~{:soso_e160:}
作者: 张雪萍    时间: 2013-3-30 23:46
  1. class Student
  2. {
  3.         String name;
  4.         int age;
  5.         Student()//无参数构造函数，
  6.         {}
  7.         Student(String name,int age)//有参数构造函数
  8.         {
  9.                 this.name=name;//设置对象的名字
  10.                 this.age=age;//设置对象的年龄
  11.         }
  12. }
  13. class  StudentDemo
  14. {
  15.         public static void main(String[] args)
  16.         {
  17.                 Student stu=new Student("zxp",20);
  18.                 System.out.println("创建学生对象的姓名："+stu.name+",他的年龄："+stu.age);
  19.         }
  20. }
复制代码
首先，构造函数是一个类默认就有的，
什么是构造函数，就是这个函数没有返回值类型，他的函数名与本类相同，而且只要类加载，他就加载，
如果我们写的类中不明确的写出构造函数，那么程序就默认有一个无参数的构造函数，，但是我们要是明确的写出来，
那么，在创建对象时，就根据你创建对象时给出的参数来选择调用哪个构造函数，比如说，上面的例子，
我创建stu对象时，我传入了String类型的zxp,和int型的20。所以，程序加载时，就会调用有参数的构造函数，无参数的构造函数就不会被调用。
有参数构造函数中的this就是指你在主函数中创建的对象，
至于你说的set，get方法，如果你把name有static来修饰，那么这个属性就变成静态的，静态的属性和函数只能在本类中使用，主函数属于另一个类，就不能直接用对象.name来使用，就必须在Student中写一个函数，让他来调用该静态属性，而该方法不是静态的，就可以在主函数中调用了，从而访问到静态的name属性。
打个比方来说，就是你不能出教室，但是在办公室的老师让你交作业，那么你的班级中就必须得有一个课代表，他可以帮你传达你的作业，
那么，你就相当于被静态了，而跑腿的课代表就是一个函数，老师就是在另一个类中的主函数。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2