【原】Java学习笔记016 - 面向对象

package cn.temptation;

public class Sample01 {
    public static void main(String[] args) {
        // this 关键字 的使用
        
        Student student = new Student();
        student.setName("张三");
        System.out.println(student.getName());
    }
}

// 学生类
class Student {
    // 成员变量
    private String name;
    
    // 构造函数
    
    // 成员方法
    // 因为觉得参数叫name这个变量名比较好听，setXXX方法中形参也想使用name这个变量名，可以么？
//    public void setName(String studentName) {
//        name = studentName;
//    }
    
    public void setName(String name) {
        // 产生警告：The assignment to variable name has no effect
        // 这里就搞不清楚了，到底是把成员变量的name赋值给了形参的name，还是把形参的name赋值给了成员变量的name？
        // 回想一下  对象名.成员变量   或者 对象名.成员方法，在这里把形参的name赋值给了成员变量的name
        // 也就是说下句中前面的name如果能标明是成员变量的name就没有问题了
//        name = name;
        
        // 考虑在setXXX方法中创建一个对象，把形参的name赋值给创建出来的对象的成员变量name，但是这样写还是有问题的
        // 因为在setXXX方法中创建出的这个对象 和 主函数中创建的对象不是一个对象，主函数中创建的对象获取其成员变量时还是得到默认值null的
//        Student student = new Student();
//        student.name = name;
        
        // 使用  this 关键字，表明把形参的name赋值给当前这个对象的成员变量name，这个this指的就是当前的这个对象
        // 通过设置断点查看到，下句的this的值为：cn.temptation.Student@7fbe847c
        // 和主函数中创建出的对象值为：cn.temptation.Student@7fbe847c      相同
        this.name = name;
        
        // 注意：
        // 上句中赋值号右侧的name根据变量调用原则：就近原则，就近找到了局部变量name的定义，它是局部变量
        // 赋值号左侧的name根据this这个当前对象的点号运算符访问到了成员变量name
    }
    
    public String getName() {
        // 下句中的name根据变量调用原则：就近原则，所以其为成员变量
//        return name;
        
        // 下句的name根据this这个当前对象的点号运算符访问到了成员变量name，效果和上句相同
        return this.name;
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // 通过IDE自动生成getXXX和setXXX方法
        // 方式1：alt+shift+s、alt+shift+r
        // 方式2：菜单项或右键，找到Source，再找到Generate getters and setters...
        
        // 通过IDE自动生成构造函数
        // 方式1：alt+shift+s、alt+shift+o
        // 方式2：菜单项或右键，找到Source，再找到Generate constructor using Fields...
    }
}

// 员工类
class Employee {
    // 成员变量
    private String name;
    private int age;

    // 构造函数
    public Employee() {

    }

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

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
//        Person person1 = new Person();
//        person1.setName("张三");
////        person1.setCountry("中国");
//        System.out.println("姓名为：" + person1.getName() + "，国籍为：" + person1.getCountry());
//        
//        Person person2 = new Person();
//        person2.setName("李四");
////        person2.setCountry("中国");
//        System.out.println("姓名为：" + person2.getName() + "，国籍为：" + person2.getCountry());
        
        // 发现问题：创建了若干个Person对象，他们的country这个成员变量都是"中国"，需要进行很多次setCountry赋值
        // 对于一系列对象具有相同的成员变量值，是否有便捷的处理方式？
        // 方式1、对成员变量使用指定的默认值，方法可行
        // 方式2、既然是描述一系列对象的相同的成员变量值，换句话说就是对象们的成员变量值，再抽象一步，对象们的抽象----->类
        
        // 引入静态的概念：static 关键字
        // static关键字可以用于成员变量 和 成员方法。用在成员变量上，成员变量就是静态成员变量；用在成员方法上，成员方法就是静态成员方法。
        
        // static的格式：
        // 静态成员变量： static    数据类型      变量名;
        // 静态成员方法：修饰符   static   返回类型   方法名(参数列表) { ... }
        
        // 使用static修饰成员变量后，对某一个对象设置了静态成员变量的值，其他没有被设置静态成员变量的对象也具有了相同的值（注意：对象们的含义）
//        Person person3 = new Person();
//        person3.setName("王五");
//        person3.country = "中国";
//        System.out.println("姓名为：" + person3.getName() + "，国籍为：" + person3.country);
//        
//        Person person4 = new Person();
//        person4.setName("赵六");
//        System.out.println("姓名为：" + person4.getName() + "，国籍为：" + person4.country);
        
        // 使用static修饰成员变量后，使用  类名.静态成员变量名  可以访问到静态成员变量，可以不创建对象
//        Person.country = "中国";
//        
//        // 再创建对象，对象的静态成员变量的值   等同于使用   类名.静态成员变量  设置的值
//        Person person5 = new Person();
//        person5.setName("钱七");
//        // 下面两句效果相同
//        System.out.println("姓名为：" + person5.getName() + "，国籍为：" + person5.country);
//        System.out.println("姓名为：" + person5.getName() + "，国籍为：" + Person.country);
//        
//        Person person6 = new Person();
//        person6.setName("王八");
//        // 下面两句效果相同
//        System.out.println("姓名为：" + person6.getName() + "，国籍为：" + person6.country);
//        System.out.println("姓名为：" + person6.getName() + "，国籍为：" + Person.country);
    }
}

//// 人类
//class Person {
//    // 成员变量
//    private String name;
////    private String country;
////    private String country = "中国";
//    public static String country;
//    
//    // 成员方法
//    public String getName() {
//        return name;
//    }
//
//    public void setName(String name) {
//        this.name = name;
//    }
//
////    public String getCountry() {
////        return country;
////    }
////
////    public void setCountry(String country) {
////        this.country = country;
////    }
//}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
        // static的特点：
        // 1、static修饰的成员伴随着类被类加载器（classloader）加载而加载的
        // 2、static修饰的这些成员变量  和  成员方法，出现的时间比对象要早（理解：只要是在大陆出生的，还没出生就确定了你的国籍是中国的）
        // 3、static描述的是类的特征 和 行为，也是对象们都具有的特征  和 行为
        // 4、static使用时，可以使用   对象名.静态成员，也可以使用  类名.静态成员，建议使用  类名.静态成员
        
        // 类名.非静态成员变量，产生语法错误
        // 语法错误：Cannot make a static reference to the non-static field Test.i
//        System.out.println(Test.i);
        // 对象名.非静态成员变量，语法正确
//        Test test = new Test();
//        System.out.println(test.i);
//        
//        // 类名.静态成员变量，语法正确
//        System.out.println(Test.j);
//        
//        Test.j = 4;
//        
//        Test testEx = new Test();
//        // 对象名.静态成员变量，语法正确
//        System.out.println(testEx.j);
//        // 类名.静态成员变量，语法正确（推荐写法）
//        System.out.println(Test.j);
    }
}

//class Test {
//    int i = 2;
//    static int j = 3;
//}

package cn.temptation;

public class Sample05 {
    public static void main(String[] args) {
        // 成员变量设置为static，其相应的封装方法也需要设置为static，否则静态成员变量在类加载时就被加载的，却因为对应的封装方法不是static的而无法使用
//        Baby.setCountry("中国");
//        
//        Baby baby = new Baby();
//        baby.setName("张三");
//        System.out.println("姓名为：" + baby.getName() + "，国籍为：" + Baby.getCountry());
    }
}

//class Baby {
//    // 成员变量
//    private String name;
//    private static String country;
//
//    // 成员方法
//    public String getName() {
//        return name;
//    }
//
//    public void setName(String name) {
//        this.name = name;
//    }
//
//    public static String getCountry() {
//        return country;
//    }
//
//    public static void setCountry(String country) {
//        // 明确显示的指出把局部变量形参赋值给  类名.静态成员变量
//        Baby.country = country;
//        
//        // 语法错误：Cannot use this in a static context     不能在一个static上下文环境中使用this
//        // 这里为什么不能使用this？    答：因为this指的是当前这个对象，既不是对象们，也不是类
////        this.country = country;
//    }
//
//}

package cn.temptation;

public class Sample06 {
    public static void main(String[] args) {
        // static关键不但可以用在成员变量上，也可以使用在成员方法上
        
        // 访问性问题
        /*
         * 1、静态成员方法
         *         只能访问静态的成员变量   和    静态的成员方法
         *         不能访问非静态的成员变量   和   非 静态的成员方法
         * 2、非静态成员方法
         *         能访问静态的成员变量   和    静态的成员方法
         *         能访问非静态的成员变量   和   非 静态的成员方法
         * 
         * 总结：    静态的只能访问静态的，非静态的都可以访问
         */
    }
}

class Demo {
    // 成员变量
    // 非静态的成员变量
    int i = 2;
    // 静态的成员变量
    static int j = 3;
    
    // 成员方法
    // 非静态的成员方法
    public void method1() {
        System.out.println(i);
        System.out.println(j);
        
        method2();
        method3();
    }
    
    public void method2() {
        
    }
    
    // 静态的成员方法
    public static void method3() {
        // 语法错误：Cannot make a static reference to the non-static field i
//        System.out.println(i);
        System.out.println(j);
        
        // 语法错误：Cannot make a static reference to the non-static method method1() from the type Demo
//        method1();
        method4();
    }
    
    public static void method4() {
        
    }
}

package cn.temptation;        // 在命令行窗口下编译执行，这句先注释掉

public class Sample07 {
    public static void main(String[] args) {
        // main主函数（主方法）
        // 1、public：公开的，可访问权限最大
        // 2、static：静态的，静态的main方法被JVM调用（因为这个main方法是Java程序的入口），调用会是一种什么形式？
        //         形式1、Sample07  对象名    = new Sample07();      对象名.main();
        //         形式2、Sample07.main();
        //         调用时，JVM自然不会先去创建一个Sample07对象的，必然是形式2，形式2需要成员方法使用static修饰，所以main主函数使用static关键字修饰
        // 3、void：无返回的，JVM不需要返回什么
        // 4、main：使用main作为主函数的方法名是一种约定
        // 5、String[] args：在Java早期使用的，用来在命令行窗口中接收命令行的参数的输入
        
//        System.out.println(args);                // [Ljava.lang.String;@15db9742
//        System.out.println(args.length);        // 0
        
        // 使用javac对当前代码文件进行编译，再使用java Sample07 "字符串1" "字符串2" "字符串3"，可以看到命令行窗口中显示出参数列表的值
        for (String item : args) {
            System.out.println(item);
        }
    }
}

package cn.temptation;

public class Sample08 {
    public static void main(String[] args) {
        // 大括号的玩法总结
        // 代码块：Java中，使用大括号{}将语句包含其中，称为代码块
        
        // 1、局部代码块（联想到局部变量）
        // 位置：在方法内
        // 作用：限定变量的作用范围
        
        // 2、构造代码块（联想到构造函数）
        // 位置：在类中，和成员变量、成员方法、构造函数同级的位置
        // 作用：从构造代码块的执行效果看，因为它的执行在构造函数之前，所以可以考虑把构造函数及其重载方法中相同的语句提取出来放在构造代码块中
        
        // 3、静态代码块（联想到静态成员）
        // 位置：在类中，和成员变量、成员方法、构造函数、构造代码块同级的位置
        // 作用：从静态代码块的执行效果看，静态代码块中的语句比构造代码块中的语句还要先执行，且只执行一次
        //        常常用于先于构造代码块等执行且只执行一次语句的场合，比如：数据库连接
        
        // 局部代码块
//        {
//            // 局部变量的声明和赋值在局部代码块内部
//            int i = 2;
//            System.out.println(i);
//        }
        // 局部代码块限定了其中的局部变量i的作用域，使得在局部代码块外的语句无法访问在局部代码块内声明的变量
        // 语法错误：i cannot be resolved to a variable
//        System.out.println(i);
        
//        int j = 3;
//        System.out.println(j);
//        {
//            // 修改局部变量赋值在局部代码块内部
//            j = 4;
//            System.out.println(j);
//        }
//        // 局部代码块外的语句可以访问在局部代码块外声明且在局部代码块内部修改赋值的变量
//        System.out.println(j);
        
        // 创建一个Test类类型的对象
        Test test = new Test();
        
        // 再创建一个Test类类型的对象
        Test testEx = new Test();
    }
    
    // 静态代码块
    static {
        System.out.println("这是Sample08类中的静态代码块");
    }
    
    // 注意：Sample08类中的静态代码块的显示先于Test类中的静态代码块的显示，这是因为类的加载先后顺序决定的（程序入口main主函数所在的类先被加载）
}

class Test {
    // 成员变量
    private int number;

    // 构造函数（无参）
    public Test() {
        System.out.println("这是无参构造函数");
        // 因为不知道会执行哪一种构造函数的形式，所以每种构造函数中都要进行对成员变量的赋值操作
//        this.number = 123;
    }

    // 构造函数（有参）
    public Test(int number) {
        System.out.println("这是有参构造函数");
        // 因为不知道会执行哪一种构造函数的形式，所以每种构造函数中都要进行对成员变量的赋值操作
//        this.number = 123;
    }
    
    // 构造代码块
    {
        System.out.println("这是构造代码块");
        // 在构造代码块中编写构造函数及其重载方法中都有的语句，这样可以节省大量的重复代码
        this.number = 123;
    }
    
    // 静态代码块
    static {
        System.out.println("这是静态代码块");
    }
    
    // 成员方法
}

package cn.temptation;

public class Sample09 {
    public static void main(String[] args) {
//        Man man = new Man();
//        man.setName("吕布");
//        man.setAge(20);
//        man.eat();
//        man.earn();
//        
//        Woman woman = new Woman();
//        woman.setName("貂蝉");
//        woman.setAge(16);
//        woman.eat();
//        woman.pay();
        
        // 发现问题：原先Man类 和 Woman类所特有的行为，在Person类上都不再是特有的了，这种Person类的设计扩大了行为能力
//        Person person1 = new Person();
//        person1.setName("吕布");
//        person1.setAge(20);
//        person1.eat();
//        person1.earn();
//        person1.pay();
    }
}

//// 男人类
//class Man {
//    // 成员变量
//    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) {
//        this.age = age;
//    }
//
//    // 自定义成员方法
//    public void eat() {
//        System.out.println("吃饭");
//    }
//
//    public void earn() {
//        System.out.println("赚钱");
//    }
//}
//
//// 女人类
//class Woman {
//    // 成员变量
//    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) {
//        this.age = age;
//    }
//
//    // 自定义成员方法
//    public void eat() {
//        System.out.println("吃饭");
//    }
//    
//    public void pay() {
//        System.out.println("花钱");
//    }
//}

// 观察Man类  和  Woman类的代码中有太多相同的代码，所以我们考虑不使用两个类去表示，就用一个类表示，考虑男人类、女人类都是人类
//class Person {
//    // 成员变量
//    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) {
//        this.age = age;
//    }
//    
//    // 自定义成员方法
//    public void eat() {
//        System.out.println("吃饭");
//    }
//    
//    public void earn() {
//        System.out.println("赚钱");
//    }
//    
//    public void pay() {
//        System.out.println("花钱");
//    }
//}

package cn.temptation;

public class Sample10 {
    public static void main(String[] args) {
        // 想把若干个不同的类的相同的成员变量和成员方法提取出来做抽象，形成一个更高级别的抽象的类
        // 但是它们的不同的成员变量和成员方法如何使用？
        
        // Java中提供了   继承   的机制
        
        // 面向对象的三大特点：
        // 1、封装性：encapsulation
        // 2、继承性：inheritance
        // 3、多态性：polymorphism
        
        // 继承的格式：    子类   extends  父类
        
        // 1、将子类中相同的成员变量 和  成员方法都抽取出来放在父类中，减少子类中的代码
        // 2、通过extends关键字，让子类使用父类中的这些相同的成员变量和成员方法，这样和把这些成员写在子类中效果相同
        
        Man man = new Man();
        man.setName("吕布");
        man.setAge(20);
        man.eat();
        man.earn();
        // 语法错误：The method pay() is undefined for the type Man
//        man.pay();
        
        Woman woman = new Woman();
        woman.setName("貂蝉");
        woman.setAge(16);
        woman.eat();
        woman.pay();
        // 语法错误：The method earn() is undefined for the type Woman
//        woman.earn();
        
        // 子类从父类继承而来，自然把父类的成员变量 和 成员方法都一股脑儿拿来使用
        
        // 【继承的优点】
        // 1、减少了代码量
        // 2、方便了修改
        // 3、丰富了类和类之间的关系
        
        // 【继承的缺点】
        // 1、继承是无法选择（不论子类要还是不要，只要继承了，都给子类了）
        // 2、类与类之间形成了较强的耦合度
        
        // 【设计的原则：好的设计，追求的是"高内聚、低耦合"】
        
        // 中国古代士大夫的自我准则：修身、齐家、平天下
        // 做好面向对象的设计准则：同上
    }
}

// 人类
class Person {
    // 成员变量
    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) {
        this.age = age;
    }
    
    // 自定义的成员方法
    public void eat() {
        System.out.println("吃饭");
    }
}

// 男人类
class Man extends Person {
    // 成员变量
    
    // 成员方法
    public void earn() {
        System.out.println("赚钱");
    }
}

// 女人类
class Woman extends Person {
    // 成员变量
    
    // 成员方法
    public void pay() {
        System.out.println("花钱");
    }
}

package cn.temptation;

public class Sample11 {
    public static void main(String[] args) {
        // 继承的特点：
        // Java中的继承是单继承，不是多继承（指的是类的继承），多继承在现实世界中是可以的，比如：小孩从父母双方继承基因
        
        // 理解单继承：
        // 1、被继承的类是单个的
        // 2、继承并不只有一层，可以是多层的（也就是继承链），但是继承链上的每一层都是单继承
    }
}

//class GrandFather {
//    
//}
//
//class Father extends GrandFather {
//    
//}
//
//class Mother {
//    
//}
//
//class Baby extends Father {        // 语法OK
////class Baby extends Mother {        // 语法OK
////class Baby extends Father, Mother {    // 语法出错
////class Baby extends Father + Mother {    // 语法出错
////class Baby extends Father Mother {        // 语法出错
//    
//}

package cn.temptation;

public class Sample12 {
    public static void main(String[] args) {
        // 继承是可以传递的
        // 只要在继承链上，链的下级可以得到上级及上级的上级的...成员变量 和 成员方法（对上级的查找是一直向上直到继承链的源头）
        
        // 通过继承链得到成员的缺点：当前类的对象使用成员时，不知道自身的成员变量或成员方法到底来自于哪一个上级
        // IDE对这个缺点进行了一些补救，使用成员变量或成员方法时，会在成员后标明是哪个上级
        Baby baby = new Baby();
        baby.showByBaby();
        baby.showByFather();
        baby.showByGrandFather();
    }
}

class GrandFather {
    public void showByGrandFather() {
        System.out.println("这是GrandFather的成员方法");
    }
}

class Father extends GrandFather {
    public void showByFather() {
        System.out.println("这是Father的成员方法");
    }
}

class Baby extends Father {
    public void showByBaby() {
        System.out.println("这是Baby的成员方法");
    }
}