Java 基础类之四

方法的重载

在同一个类中，允许存在一个以上的同名方法，只有它们参数个数不同或者参数类型即可

package com.chenxiTeat.com.chenxiTeat;
/*
方法重载（overload）
在同一个类中，允许存在一个以上的同名方法，只要他们参数或者参数类型不同即可。
“两同一不同”；同一个类、相同方法名参数列表不同
举例
Arrays类中重载sort()/binrySearch()
判断是否属于重载：
跟方法的权限修饰、返回类型、形参变量名、方法体都没有关系！
通过对象调方法时，如何确定哪个指定的方法
方法名----->参数列表
当调用可变个数形参的方法时，传入的参数个数可以时0个1个2给
可变个数形参的方法与本类中方法名相同，形参个数不同的方法构成重载
2.4可变个数形参的方法与本类中方法名字形态，形参类型也相同的数组不构成重载

 */
public class OverLoadTest {
    public static void main(String[] args){
        OverLoadTest test = new OverLoadTest();
        test.getSum(1,2);
        OverLoadTest test1 = new OverLoadTest();
        test1.moL("hhhhdfdgxfcgh");

    }
    //如下4个方法构成了重载
//    public void getSum(int i,int j){
//        System.out.println(i+j);
//    }
    public void getSum(double d1,double d2){
        System.out.println("2");

    }
    public void getSum(int i,String s){
        System.out.println("3");

    }
    public void moL(int i){
        System.out.println(i*i);
    }
    public void moL(int i,int j){
        System.out.println(i*j);
    }
    public void moL(double s){
        System.out.println(s);
    }
    public int max(int i,int j){
        return (i>j)? i:j;//如果i大于j；则返回i，否则返回j
    }
    public double max(double d1,double d2,double d3){
        double max = (d1>d2)?d1:d2;
        return (max>d3)? max:d3;
    }
    //可变类型的形参
    //具体使用
    //可变类型的格式：数据类型...变量名
   // 当调用可变个数形参的方法时，传入的参数个数可以时0个1个2给
   // 可变个数形参的方法与本类中方法名相同，形参个数不同的方法构成重载
//2.4可变个数形参的方法与本类中方法名字形态，形参类型也相同的数组不构成重载

    public void moL(String ... strs){
        System.out.println("show(String ... strs)");
    }
    public void moL (int i,String ...strs){

    }
}

　　封装和隐藏性

创建一个类的对象后，可以通过对象.属性的方法，对对象属性进行进行赋值，赋值操作要收到属性的数据类型和存储范围的制约，除此之外没有其他的制约条件，但是在实际问题中，往往需要给属性赋值时加额外条件，这条件就不能在属性声明时体现，只能通过方法限制添加，同时需要避免用户使“对象.属性”的方法对属性赋值，则需要将属性设置为私有的（private）权限修饰符。私有权限修饰符（private）--->此时，属性就体现为封装性

package com.chenxi.java;

public class Anma {
    public static void main(String[] args){
        Animal a=new Animal();
        a.name="格林";
        //a.age=8;
        a.legs= 4;
        a.setLegs(6);
        a.show();

    }
}
class Animal{
    String name;
    private int age;//声明私有属性
    int legs;
    public void eat(){
        System.out.println("进食");
    }
    public void show(){
        System.out.println(name+age+legs);
    }

    public void setLegs(int i){
        if (i>=0 && i%2==0){
            age = i;
        }else {
            age = 0;
        }
    } 

}

　　 封装性的体现：属性的私有化，方法的私有化，单模式

封装性的体现，需要权限修饰符来配合

Java权限修饰符（从小到大）：private、缺省、protected 、public 

四种权限可以用来修饰类的内部结构：属性、方法、构造器、内部类

修饰类只能用：public和缺省

Java权限修饰符public、protected、(缺省)、private置于类的成员定义前， 用来限定对象对该类成员的访问权限。 

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes
(缺省)	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

对于class的权限修饰只可以用public和default(缺省)。

 public类可以在任意地方被访问。

 default类只可以被同一个包内部的类访问。、

示例

package com.chenxi.java;

public class Order {
    private int orderPrivate;
    int orderDefault;
    public int orderPublic;
    public void methodPublic(){
        orderPrivate=1;
        orderDefault=2;
        orderPublic=3;
    }
    void methodDefault(){
        orderPrivate=1;
        orderDefault=2;
        orderPublic=3;
    }
    private void methodPrivate(){

    }
    protected void methodProtected(){
        orderPrivate=1;
        orderDefault=2;
        orderPublic=3;
    }

}

　　同一个包内测试

package com.chenxi.java;

public class OrderTest {
        public static void main(String[] args){
            Order test1=new Order();
            test1.orderPublic=10;
            test1.orderDefault=6;
            //'orderPrivate' has private access in 'com.chenxi.java.Order'
            test1.orderPrivate=10;//出了order类，私有结构声明的不可再用了
            test1.methodProtected();
            System.out.println(test1.orderDefault);

        }
}

　　不同包内测试

package com.chenxi1.com;

import com.chenxi.java.Order;

public class test01 {
    public static void main(String[] args){
        Order test1=new Order();
        test1.orderPublic=10;
        //orderDefault' is not public in 'com.chenxi.java.Order'. Cannot be accessed from outside package
        test1.orderDefault=6;//出了order类所属的包后，私有结构缺省声明的不可再用了
        //'orderPrivate' has private access in 'com.chenxi.java.Order
        test1.orderPrivate=10;//出了order类所属的包后，私有结构缺省声明的不可再用了
        System.out.println(test1.orderDefault);

    }
}

   .创建程序,在其中定义两个类：Person和PersonTest类。定义如下： 用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。 在PersonTest类中实例化Person类的对象b， 调用setAge()和 getAge()方法，体会Java的封装性。 

package com.chenxi.exer;
/*
类的创建
.创建程序,在其中定义两个类：Person和PersonTest类。定义如下：
 用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。
  在PersonTest类中实例化Person类的对象b， 调用setAge()和 getAge()方法，体会Java的封装性。

 */
public class Person {
    private int age;
    public void setAge(int a){
        if(a<0||a>130){
            throw new RuntimeException("输入错误");
        }else {
            age=a;
        }
    }
    public int getAge(){
        return age;
    }

}

　　类的实例化

package com.chenxi.exer;

public class PersonTest {
    public static void main(String[] args){
            Person personi= new Person();
            personi.setAge(8);
            System.out.println(personi.getAge());
    }
}

　　测试

8