已知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;
        }
}

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属性。
打个比方来说，就是你不能出教室，但是在办公室的老师让你交作业，那么你的班级中就必须得有一个课代表，他可以帮你传达你的作业，
那么，你就相当于被静态了，而跑腿的课代表就是一个函数，老师就是在另一个类中的主函数。

真心谢谢你们了~{:soso_e160:}

1. A
   
2. 
   
3. 
   
4. public class Demo {
   
5. 
   
6.         /**
   
7.          * @param args
   
8.          */
   
9.         public static void main(String[] args) {
   
10.        
    
11.                 Student p = new Student("张三",20 );        
    
12.               p.method();
    
13.           
    
14.         }
    
15. 
    
16. }
    
17. 
    
18. B
    
19. 
    
20. 
    
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.         }
    
38. 
    
39.        
    
40.        
    
41. }       
    

复制代码

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();
        }
       
}

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. }   
    
15. 
    
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. }  

复制代码

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);
        }
}


感觉这个比较靠谱

嘿嘿 楼主比较实在，楼主的这句话挺逗“这是我下面的代码。学的已经乱套了”

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

面向对象的封装，就是把一个对象的属性和行为（方法）封装到一个模块（类）中，
通常是将属性私有化，在提供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;
        }

}

同时还可以提供构造方法在里面    一些数值的传递我就不多说了，怕地方不够了 嘿嘿

1. package A;
   
2. 
   
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.         }
    
41. 
    
42.         }
    

复制代码

你注意两次输出的代码。

我明你说的意思
本身你的代码就是错的

正确答案因该是：
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());

}
}
希望帮到你！