面向对象---回顾2

成员方法

java中不存在全局方法，所有方法都是成员方法。

成员方法分为两种：类方法（使用 static 修饰的方法），实例方法（不使用 static 修饰的方法）。

类方法通过类名调用，实例方法通过对象调用。

public class Person{
	String name;//实例变量
	char gender;//实例变量
	int age;//实例变量
	static int count;//类变量
	
	//实例方法
	//实例方法可以操作调用此方法对象的实例属性
	public void showInfo(){
		System.out.println("我叫" + name);
        System.out.println("我的性别是" + gender);
        System.out.println("我今年" + age + "岁了");
        
        //实例方法可以访问类变量
        System.out.println("有" + count + "个对象");
	}
	
	//类方法
	//类方法用于操作类变量
	public static void setCount(int newCount){
		count = newCount;
		
		//类方法不能访问实例变量
//		System.out.println(name);//编译错误
    }
    
    //类方法
    //类方法用于操作类变量
    public static int getCount(){
    	return count;
    }
}

public class Face_to_Object{
	public static void main(String[] args) {
		Person p1 = new Person;
		p1.name = "张三";
		p1.gender = '男';
		p1.age = 20;
		
		//类方法通过类名调用
		Person.setCount(1);
		
		//实例方法通过对象调用
		p1.shoeInfo();
		
		Person p2 = new Person();
		p2.name = "李斯";
		p2.gender = '女';
		p2.age = 21;
		
		//通过类名来调用类方法
        //类方法是属于类的，使用类方法，不必事先创建对象
		Person.setCount(Person.getCount() + 1);
		
		//通过对象来调用实例方法
		p2.showInfo();
		
		System.out.println("有" + Person.getCount() + "个对象");//2
	}
}

构造器

构造器也叫构造方法或构造函数，用于初始化对象。

构造器是一个类中的与类名相同的方法，无返回值，不能使用void修饰。

java编译器默认提供一个无参数的构造器，若手动添加构造器，则默认的无参的构造器就会消失。

一个类中可以有多个构造器，构造器可以被重载。

public class Student{
	// 编译器默认提供无参构造器，构造器的方法名与类名相同，如下
	// public Student(){};
	
	String name;
	int age;
	
	// 如果提供了一个构造器，那么编译器就不会提供默认的构造器
	// 构造器的名称必须与方法名相同
	// 构造器没有返回值，并且不使用void
	
	// 构造器的重载
	public Student(){
		System.out.println("Student构造器")
	}
}

public class Object_oriented{
	public static void main(String[] args) {
		//当使用new操作符创建类的一个实例时，构造器会被调用。
		//没有构造器不能创建对象，如果没有构造器，编译器会提供一个默认的无参构造器
		
		//调用无参构造器
		Student p1 = new Student(p1);
		
		Student p2 = new Student(p2);
		
		System.out.println(p1);
		System.out.println(p2);
		
		//调用有参构造器
		Student p3 = new Studnet("张三", 10);
		Studnet p4 = new Student("李斯", 15);
		
		System.out.println(p3.name);//张三
		System.out.println(p4.age);//15
	}
}

this 关键字

每一个实例方法和构造器都有一个隐式参数this。

在实例方法中，this代表调用此方法的对象，在构造器中this代表当前被创造的对象。

public class Teacher {
    String name;
    int age;

    public Teacher(String name, int age){
//        调用构造器时，对象还没有被创建
//        在构造器中，this代表当前被创建的对象

        this.name = name;
        this.age = age;
        System.out.println(this);
    }
    public void setName(String newName){
//        给调用此方法对象的name属性赋值
//        在实例方法中，this表示调用此方法的对象

        this.name = newName;
        System.out.println(this);
    }
    public void setAge(int age) {
        this.age = age;
        System.out.println(this);
    }
}

使用this，构造器可以调用构造器

public class Animal {
//    一个类中可以存在多个构造器
//    根据参数进行区分
    String name;
    int age;
    String type;

    public Animal(String name ){
        this.name = name;
    }

    public Animal(String name , int age){
//        调用上面的构造器
        this(name);
        this.age = age;
    }

    public Animal(String name, int age, String type){
        this(name, age);
        this.type = type;
    }
}

public class Object_oriented {
    public static void main(String[] args) {

        Animal a1 = new Animal("鸽子", 1, "鸟类");
        System.out.println(a1.name);
        System.out.println(a1.age);
        System.out.println(a1.type);
    }
}

访问权限修饰符

类可以使用public关键字修饰，指示这个类是公有的，可以被其他无关类访问（包括同一个包下的和不同包下的类）。

如果不加修饰符，则认为这个类是默认访问权限，可以被同一个包下的无关类访问。

成员变量与成员方法的访问权限如下表：

	本类	同一个包下的无关类	不同包下（子类）	不同包下（无关类）
private	Y
default(默认)	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

数据封装

隐藏对象内部的数据，并要求通过方法执行所有的交互称为数据封装。

具体操作是把所有属性设置为private的，并提供getter和setter方法。

主要作用是避免外部直接访问和修改实例变量，保护数据合法性。

public class Child {
    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) {
        if(age <= 0 || age >=150){
            System.out.println("年龄非法");
            return;
        }
        this.age = age;
    }
}

   public static void main(String[] args) {

        c.setAge(10);
        c.setName("王麻子");
        System.out.println(c.getName());
        System.out.println(c.getAge());

    }

对象作为方法参数

以数组作为参数情况，可以将多只宠物的年龄录入系统

宠物店现在需要将单一物种的所有信息录入系统中，就可以将对象作为方法参数。

public class Cat {
    private String name;
    private int age;

    public Cat(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; }
}

import static Object_oriented.Cat.m1;

public class Object_oriented {
    public static void main(String[] args) {

        Cat c1 = new Cat("橘猫", 1);
        System.out.println(c1.getAge());//1
        m1(c1);
        System.out.println(c1.getAge());//4
    }
}