Java从入门到精通04-类、对象

Java语言是面向对象的，计算机语言的发展向接近人的思维方式演变；

类和对口箱的区别和联系
1、类是抽象的，概念的，代表一类事物，比如人类、猫类...
2、对象是具体的，实际的，代表一个事物，比如张三、李四...
3、类是对象的模板，对象是类的一个个体、实例；

一个全面类的定义模板：

package 包名;
class 类名 extends 父类 implements 接口名{
    成员变量;
    构造方法;
    成员方法;
}

类的成员方法的参数可以是多个，方法可以没有返回值；

构造方法是类的一种特殊方法，它的主要作用是完成对新对象的初始化，它有如下特点：
1、构造方法名和类名相同；
2、构造方法没有返回值；
3、主要作用是完成对新对象的初始化；
4、在创建一个类的新对象时，系统会自动的调用该类的构造方法完成新对象的初始化；
5、一个类可以定义多个构造方法；
6、每个类都有一个默认的构造方法，当定义了构造方法后，将会替换默认构造方法；

class Person{
    int age;
    String name;
    //构造方法
    public Person(int age,String name){
        this.age=age;
        this.name=name;
    }
}

this不能再类定义的外部使用，只能在类定义的方法内使用。

类变量是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的值都是相同的，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

类变量的定义方法：访问修饰符 static 数据类型 变量名；
类变量的访问方法：类名.类变量名 或者 对象名.类变量名；

public class Child {
    int age;
    String name;
    static int total = 0;   //静态变量，可以被任何一个对象访问

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

    public void joinGame() {
        total++;
    }
}

类方法属于所有对象实例的，形式如：访问修饰词 static 数据返回类型 方法名(){}；
类方法中不能访问非静态变量（类变量）；
类方法可以通过"类名.类方法名"直接访问；
类方法属于与类相关的公共方法；

public class Student {
    int age;
    String name;
    int fee;
    static int totalFee;

    public Student(int age, String name, int fee) {
        this.age = age;
        this.name = name;
        totalFee += fee;
    }

    //返回总学费，这是一个类方法，节省内存开销,原则上通过"类名.类方法"去访问
    public static int getTotalFee() {
        return totalFee;
    }
}

Java面向对象编程的四大特征：抽象、封装、继承、多态；

抽象：就是把一类事物的共有属性和行为提取出来，形成一个屋里模型，这种研究问题的方法称为抽象；
封装：就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（成员方法），才能对数据进行操作；
继承：可以解决代码复用，让我们的编程更加靠近人的思维，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有子类不需要重新定义这些属性和方法，只需通过extends语句来声明继承父类，class 子类 extends 父类；父类的public、protected和默认的都可以继承；
多态：就是指一个引用在不同情况下的多种状态，也可以理解为：多态是指通过指向父类的指针，来调用在不同子类中实现的方法。

继承注意事项：
1、子类最多只能继承一个父类（指直接继承）；
2、java所有类都是Object类的子类；
3、jdk中的包中包含类、接口、异常、枚举、注释和错误；

访问控制修饰符
1、公开级别：用public，对外公开；
2、受保护级别：用protected修饰，对子类和同一个包中的类公开；
3、默认级别：没有修饰符，向同一个包的类公开；
4、私有级别：用private修饰，只有类本身可以访问，不对外公开；

包（package）的作用：
1、区分相同名字的类；
2、当类很多时，可以很好的管理类；
3、控制访问范围；

方法重载（overload）：就是在类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数；
1、方法名相同；
2、方法的参数类型，个数，顺序至少有一项不同；
3、方法返回类型可以不同；

方法覆盖（override）：就是子类有一个方法和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法。
1、子类的方法的返回类型、参数、方法名称，要和父类方法的返回类型、参数、方法名称完全一样；
2、子类方法不能缩小父类方法的访问权限；

public class Demo {
    public static void main(String args[]) {
        Master master = new Master();
        master.feed(new Dog(), new Bone());
        master.feed(new Cat(), new Fish());
    }
}

class Animal {
    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 void cry() {
        System.out.println("不知道怎么叫");
    }

    public void eat() {
        System.out.println("不知道吃什么");
    }
}

class Cat extends Animal {
    public void cry() {
        System.out.println("喵喵叫");
    }

    public void eat() {
        System.out.println("猫喜欢吃鱼");
    }
}

class Dog extends Animal {
    public void cry() {
        System.out.println("汪汪叫");
    }

    public void eat() {
        System.out.println("狗喜欢吃骨头");
    }
}

class Food {
    String name;

    public void showName() {

    }
}

class Fish extends Food {
    public void showName() {
        System.out.println("鱼");
    }
}

class Bone extends Food {
    public void showName() {
        System.out.println("骨头");
    }
}

class Master {
    //使用多态，方法就可以用一个
    public void feed(Animal an, Food f) {
        an.eat();
        f.showName();
    }
}