2017暑假 第四周 学习总结（复习）

---

2017暑假 学习总结目录：　　　1　　　2　　　3　　　4

---

Time：7.24 ~ 7.30

---

Content

---

• 主要学习内容：
  • ① 对象的创建和调用
  • ② 匿名对象
  • ③ 构造函数
  • ④ this的使用
  • ⑤ super的使用
  • ⑥ 函数的重载和重写
  • ⑦ 3个重要的修饰符

• 本周感想

---

主要学习内容：

1. 对象的创建和调用

• 所谓的“面向对象”是以“对象”为中心的，在Java中一个类就代表一个对象，要想弄清楚对象的创建和调用过程，就要先了解各种变量的特征和位置，成员变量是属于对象的，如果某个对象发生改变不会影响其他对象，静态变量属于类对象，是所有对象公有的，如果其中一个发生变化，其他的也跟着发生变化。在调用对象时，在本类的main方法中静态变量和成员变量的调用方式不同，静态方法和非静态方法的调用方式也不同，在不同类中仍然如此。如果不是有了像IDEA、Eclipse等这种自动查错的工具，恐怕练习这部分内容时效率会很低。关于成员变量和静态变量的区别，我之前一直搞混，现在举个例子：

public class Demo{
    public static void main(String[] args) {
        Demos d = new Demos();
        // 修改成员变量的值
        d.age = 100;
        // 修改静态变量的值
        Demos.num = 200;
        System.out.println(d.age);
        System.out.println(Demos.num);
        Demos demo = new Demos();
        System.out.println(demo.age);
        System.out.println(Demos.num);
    }
}
class Demos {
    // 静态变量
    static int num = 10;
    // 成员变量
    int age = 15;
}

运行结果就可以看出明显的区别：

两个对象，一旦改变一个对象的静态变量的值，在调用的时候按照执行顺序后面的其他静态变量的值都会发生变化，而成员变量则根据每个对象而定。

2. 匿名对象

• 所谓的匿名对象，就是指没有引用类型变量指向的对象，试用在只调用一次方法的时候，如果调用多个方法，没有一般调用方法（实例化类对象后再调用）的方式效率高。举个简单的例子：

public class Demo {
    public static void main(String[] args) {
        // 实例化类对象
        Student stu = new Student();
        stu.study();
        stu.run();
        new Student().study();
        new Student().run();
        // 调用属性
        System.out.println(new Student2().name = "王小二");
    }
}
class Student {
    int num;
    String name;

    public void study() {
        System.out.println("Cheer up!");
    }

    public void run() {
        System.out.println("Running.");
    }
}

这种方式可以简化代码，在调用多个方法时也可以使用匿名对象，但是效率较低。

3. 构造函数

• 构造函数这部分内容我比较熟悉，只是觉得需要复习，其中最关键的一点：在java中，如果一个类没有构造函数，系统会帮助我们自动创建一个无参数的构造函数，一旦有了自己的构造函数，默认的构造函数就不存在了。构造函数的方法名和类名一致，并且没有返回值类型。同样，举一个简单的例子：

public class Demo {
    public static void main(String[] args) {
        Student a = new Student("小丽", 20, "女");
        System.out.println(a);
        Student b = new Student("小红", 22, "女");
        System.out.println(b);
        Student c = new Student("小强", 24, "男");
        System.out.println(c);
    }
}
class Student {
    private String name;
    private int age;
    private String sex;

    public Student(String name2, int age2, String sex2) {
        name = name2;
        age = age2;
        sex = sex2;
    }

    public String toString() {
        return "name: " + name + ", age: " + age + ", sex: " + sex;
    }
}

注意构造函数和普通函数的区别。

4. this的使用

• 注意this的三种用法，还有this不能在静态方法中使用，在这里继续举例说明：

public class Demo {
    String name = "Tom";

    public void test() {
        String name = "Jim";// 局部变量
        System.out.println("方法内的name：" + name);
        // 调用成员变量
        System.out.println(this.name);
    }

    public void testDemo() {
        this.test();// 调用其他的函数信息
    }

    public Demo() {
        this("kevin");
        System.out.println("无参数的构造函数");
    }

    public Demo(String name) {
        this("kevin", 23);
        System.out.println("有参数的构造函数" + name);
    }

    public Demo(String name, int age) {
        System.out.println("姓名为：" + name + ",年龄为：" + age);
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
    }
}

5. super的使用

• 关于super，用法和this差不多，只不过this在当前类中使用，super是在继承关系的子类中使用， 在这里不举例说明了。

6. 函数的重载和重写

• 关于重载和重写，也需要复习，以免弄混，重载必须在同一个类中，函数名相同，参数列表不同，与返回类型和访问权限无关。而重写用于继承关系，存在于子类中，函数名相同并且参数列表必须相同，举例如下：

public class Demo {
    public static void main(String[] args) {
        // 获取爷爷辈的财产
        YeYe yy = new YeYe();
        yy.printHouse();
        // 获取父类的信息
        Father fh = new Father();
        fh.printCar();
        fh.printHouse();
    }
}
class YeYe {
    private String name = "老王";
    public void printHouse() {
        System.out.println("一套房子");
    }
}
class Father extends YeYe {
    private String name = "小王";
    public void printCar() {
        System.out.println("一辆车子");
    }

    /**
     * 重写获取房子方法
     */
    public void printHouse() {
        System.out.println("两套房子");
    }
}

面向对象的继承关系也随之体现。

7. 3个重要的修饰符

• static、abstract和final，关于static之前举过例子，注意非静态函数可以直接访问静态或者非静态函数，但是静态函数中不能直接访问非静态函数，可以直接访问静态函数。关于abstract，主要修饰抽象类，抽象类不能被实例化对象。关于final，主要用于定义常量，常和static一起使用，注意：final不能用来修饰构造函数，被final修饰的方法不能被重写，被final修饰的类不能被继承，里面的方法也是final方法。列举一个简单的final实例：

public class Demo {
    static final int A = 10;

    public static void main(String[] args) {
        // a=19 会自动报错
        System.out.println(A);
    }
}
class Test {
    /**
     * final测试方法
     */
    final void testDemo() {
        System.out.println("final方法");
    }

    class Demo extends Test {
        // final void testDemo(){ 会自动报错
        // System.out.println("final方法...");
    }
}

【Return Content】

本周感想：

  第四周是计划复习的最后一周，简单来说，这一个月的复习有些效果，我弥补了一些漏洞，也巩固了大体的内容，除了IO流和接口之外其他内容基本复习到，陈列在博客中的是我认为比较重要或者之前不太熟悉的内容，最后我也跟着视频进行了相关考试，虽然掌握仍有漏洞，可是最后成绩还是比较满意的。八月份，我也会尽量保持着这种“放松不放纵”的学习节奏，继续对之前未解决的问题进一步学习，开学时争取能够轻松一些，不被其他同学甩掉太远。

【Return Content】

转载于:https://www.cnblogs.com/super925/p/7277342.html