java面向对象（上）

java方法重载

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

代码

package com.atguigu.java;

public class OverLoadTest {
    public void getSum(int i, int j) {
        System.out.println("1");
    }
    public void getSum(double i, double j) {
        System.out.println("2");
    }
    public  void getSum(int i, double j) {
        System.out.println("3");
    }
    public  void getSum(double i, int j) {
        System.out.println("4");
    }
}

可变个数形参

代码

package com.atguigu.java;
/*
* 1.jdk5.0新增的内容
* 2.具体说明
*   2.1可变个数形参的格式，数据类型。。。变量名
* 2.2当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个，等等
* 可变个数形参在方法的形参中必须声明在末尾
* 可变个数形参在方法的形参中，最多只能声明一个可变形参
* */
public class MethodArgsTest {
    public static void main(String[] args) {
        MethodArgsTest test = new MethodArgsTest();
        test.show(12);
        test.show("hello","babe");
    }
    public void show(int i) {

    }
//    public void show(String s) {
//        System.out.println("show(String)");
//    }
    public void show(String ...strs) {
        //相当于一个字符串数组
        System.out.println("show(String...strs)");
        for(int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    }
    public void show(int i, String...strs) {

    }
}

java参数传递

代码

package com.atguigu.java;

import java.sql.Array;

/*
* 如果变量是基本数据类型，此时赋值的是变量所保存的数据值
* 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值
* */
public class ValueTransferTest {
    public static void main(String[] args) {
        Order o1 = new Order();
        o1.id = 1001;
        Order o2 = o1;
        System.out.println("o1 = "+o1.id+",o2 = "+o2.id);
        o2.id = 1002;
        System.out.println("o1 = "+o1.id+",o2 = "+o2.id);
        Order o3 = new Order();
        o3 = o1;
        o3.id = 1003;
        //此时o1的值也会被改变
        System.out.println("o1 = "+o1.id+",o3 = "+o3.id);

        int[] arr1 = new int []{1,2,3,4};
        System.out.println(arr1);

        char[] arr2 = new char []{'a','b','c'};
        System.out.println(arr2);
    }
}
class Order{
    int id = 0;
}

扩展：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

封装性的体现

程序设计追求高内聚，低耦合。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉。
低耦合：仅对外暴露少量的方法用于使用。

Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及内部结构在被调用是的可见性的大小。
体现一：将类的属性xxx私有化（private）,同时提供公共的方法来获取和设置此属性的值。
体现二：不对外暴露的私有的方法。
体现三：单例模式。
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

代码

//Order.java
package com.atguigu.java;

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

    }
    void methodDefault() {
        orderPrivate = 1;
        orderDefault = 2;
        orderPublic = 3;
    }
    public void methodPublic() {
        orderPrivate = 1;
        orderDefault  = 2;
        orderPublic = 3;
    }
}

//OrderTest.java
package com.atguigu.java;

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();
        order.orderDefault = 1;
        order.orderPublic = 2;
        //order.orderPrivate = 3;//has private access
        //出了order后，私有的结构就不可以调用了
        order.methodDefault();
        order.methodPublic();
    }

}

类的结构之构造器

构造器的作用：
1.创建对象。
2.初始化对象的信息。
使用说明：
1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器。
2.定义构造器的格式，权限修饰符，类名（形参列表）{}。
3.一个类中定义的多个构造器，彼此构成重载。
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器。
5.一个类中，至少会有一个构造器。

代码

package com.atguigu.java1;
/*
*
* 类的结构之三：构造器（或构造方法：constructor)的使用
* construct,construction constructor
*一。构造器的作用：
* 创建对象
* 二。说明
*1.如果没有显式地定义类的构造器的话，则系统默认提供一个空参的构造器
* 2.定义构造器的格式，权限修饰符 类名（形参列表）{}
* 3.一个类中定义的多个构造器，彼此构成重载
* */
public class PersonTest {
    public static void main(String[] args) {
        //创建类的对象:new+构造器
        Person p = new Person();

        p.eat();

        Person p1 = new Person("vox");

        Person p2 = new Person("shoto",17);
    }
}
class Person{
    private String name;
    private int age;
    public Person() {
        System.out.println("Person()....");
    }
    public Person(String n) {
        name = n;
    }
    public Person(String n,int a) {
        name = n;
        age = a;
    }
    public void eat() {
        System.out.println("人要吃饭");
    }
    public int getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
    public void setName(String na) {
        name = na;
    }
    public void setAge(int a) {
        age = a;
    }
}

this关键字

在类的构造器中，可以显式的使用“this(形参列表)调用其他构造器，
但必须放在当前构造器的首行。