Java学习历程（5）——构造方法与方法的重载

构造方法与方法的重载

1对成员属性与成员方法的补充

上一章中，我们知道了数据需要具有稳定性，安全性，用private可以对数据进行保护
用public类方法set()等可以规范其修改方式并且避免直接用对象修改数据。那么如果个方法被拿到了，别人不也是想改就改吗？他与原来的有什么区别呢？

        public class  TestUser{
                public static void main(String[] args){
                    User A = new User(); 
                    A.set(6);
                    int G = A.get();
                    System.out.println("A.b.Uid:" + G);
                }
        }
        /*
        D:\A\B>java TestUser
        Mistake！！
        A.b.Uid:15
        */
		结果输出了Mistake，其赋值并没有成功，数据没有被更改！
         这样我们就为他修改数据增加了限定条件。
        class User
        {
            private int Uid = 15;
            public void set(int id){
                if(id > 10 && id < 100)
                    Uid = id;
                else System.out.println("Mistake！！");
            }
            public int get(){
                return Uid;
            }
}

-private(不可修饰类):其他类不可访问被private修饰的方法和变量，但是同一类中的方法可以调用它。
            public class  TestUser{
                public static void main(String[] args){
                    TestUser A = new TestUser(); 
                    A.uPut();
                }
                private void uPut(){
                        System.out.println("A");
                    //输出A
                    }
        }

            public class  TestUser{
                            private void uPut(){
                                    System.out.println("A");
                                /*
                                D:\A\B>javac TestUser.java
                                TestUser.java:11: 错误: uPut() 在 TestUser 中是 private 访问控制
                                                    A.uPut();
                                                     ^
                                1 个错误
                                */
                                }
                    }
             class User
             {
                  public static void main(String[] args){
                         estUser A = new TestUser(); 
                         A.uPut();
                  }
             }

构造方法（构造器）

类分为哪几个部分？
-成员属性，类所共有的特征属性
-成员方法，类所共有的方法行为描述。
它类似于结构体，我们要使用他就必须建立一个对象(类的实例)否则其没有任何意义。
此时我们需要用关键字new来创建一个对象，在Jvm堆内存空间申请开辟一块空间用来产生一个对象
如：
class Student{
		int i;
		public void wuHu();
        public static void main(String[] args){
		Student A = new Student();
        }
}

基础数据类型	Short	Int	Long	Char	Byte	String(引用数据类型)
默认值	0	0	0	’ ’ （空）	null	null

由此我们可以知道构造方法在堆内存中开辟空间生成对象并给对象的成员属性赋初始值。
如果我们没有定义构造器的参数，那么系统会默认使用一个无参构造，成员属性会被赋默认值。如-TestUser();
-我们只能通过构造器构造对象。
    构造方法有什么特点？
    1.方法名与类名一致。
    2.没有返回值。
    3.无参时系统默认为一个无参构造。当我们定义了一个有参构造时，系统默认的无参构造将消失。
    4.参数个数最多为成员属性的个数，一旦超出将会编译报错。
    5.形参列表要与成员属性类型相匹配否则编译报错。
    
    3例子
    public class  TestUser{
	int b;
    String c;
        public static void main(String[] args){
			TestUser A = new TestUser(3,"wuhu"); 
			TestUser B = new TestUser(); 
            /*
            D:\A\B>javac TestUser.java
            TestUser.java:6: 错误: 无法将类 TestUser中的构造器 TestUser应用到给定类型;
                                    TestUser B = new TestUser();
                                                 ^
              需要: int,String
              找到: 没有参数
              原因: 实际参数列表和形式参数列表长度不同
            1 个错误
            
            此时我们需要人为定义一个无参构造。
            */
            System.out.println(A.b);
            System.out.println(A.c);
		}
     public TestUser(int tb,String tc){
         b = tb;
         c = tc;
     }
}
		4例子
         public class  TestUser{
	int b;
        public static void main(String[] args){
			TestUser A = new TestUser(3,"wuhu"); 
            /*
             TestUser.java:4: 错误: 无法将类 TestUser中的构造器 TestUser应用到给定类型;
                                    TestUser A = new TestUser(3,"wuhu");
                                                 ^
              需要: int
              找到: int,String
              原因: 实际参数列表和形式参数列表长度不同
            1 个错误
            */
            System.out.println(A.b);
		}
     public TestUser(int tb){
         b = tb;
     }
}

无参构造
例如：
    public class  TestUser{
    Byte a;
	long b;
    String c;
        public static void main(String[] args){
			TestUser A = new TestUser(); 
		   System.out.println(A.a);
            System.out.println(A.b);
            System.out.println(A.c);
		}
		/*则其输出
		null
    	0
    	null
    	可见其无参数时的初始值。
    	*/
}
-我们要注意的是A只是一个对象的引用，他存放的是对空间内对象的首地址。

有参构造
    例如：
    public class  TestUser{
	int b;
    String c;
        public static void main(String[] args){
			TestUser A = new TestUser(3,"wuhu"); 
            System.out.println(A.b);
            System.out.println(A.c);
		}
     public TestUser(int tb,String tc){
         b = tb;
         c = tc;
     }
		/*则其输出
        D:\A\B>java TestUser
        3
        wuhu
        可见其参数为成员属性附了初始值。
    	*/
}

方法的重载

什么是方法的重载？
-方法的重载是定义多个同名的方法，每个方法参数都有所不同，用来简化不同数据类型下的各种重复功能的语句，java编译器会自动为我们找到相对应的合适的方法。
如何定义？
1.定义多个同名的方法。
2.参数类型不同，或参数类型顺序不同，参数个数不同。

如构造方法的重载也是一样。
    例子:
	 public class  TestUser{
	 int b;
	 String c;
        public static void main(String[] args){
            TestUser A = new TestUser(); 
            TestUser B = new TestUser(3,"wuhu"); 
            TestUser C = new TestUser("wuhu",3); 
            TestUser D = new TestUser("wuhu"); 
            TestUser E = new TestUser(3); 
            System.out.println("A" + ' '+ 0);
            System.out.println("B" + ' '+ B.b + B.c);
            System.out.println("C" + ' '+ C.b + C.c);
            System.out.println("D" + ' '+ D.c);
            System.out.println("E" + ' '+ E.b);
            /*
                D:\A\B>java TestUser
                A 0
                B 3wuhu
                C 3wuhu
                D wuhu
                E 3
                这就是实现了方法的重载，避免了每种数据类型都设一个新方法名的情况
                同时我们也可以看出System.out.println()也运用了方法的重载，只不过它已经写好了，我们只			   需要调用它即可。
            */
		}
         public TestUser(){}
         public TestUser(int tb,String tc){
         b = tb;
         c = tc;
     }
         public TestUser(String tc,int tb){
         b = tb;
         c = tc;
     }
         public TestUser(int tb){
         b = tb;
     }
         public TestUser(String tc){
         c = tc;
     }
}

 b = tb;
     c = tc;
 }
     public TestUser(String tc,int tb){
     b = tb;
     c = tc;
 }
     public TestUser(int tb){
     b = tb;
 }
     public TestUser(String tc){
     c = tc;
 }

}