2019-05-24 java学习日记

面向对象

代码块的概述与分类

在java中，使用 { } 括起来的被称为代码块

代码块分类：

根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块（多线程讲解）

常见代码块的应用：

局部代码块：

　　在方法内出现，限定变量的生命周期，及早释放，提高内存利用率

构造代码块（初始化块）：

　　在类中方法外出现；多个构造方法中相同的代码存放在一起，
　　每次跳用构造都执行，并且在构造方法前执行

静态代码块：

　　1，在类中方法外出现，加了static修饰

　　2，在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候执行，并且只执行一次

　　3，一般用于加载驱动

比方法便优先执行，

class Demo1_Code {
    public static void main(String[] args) {
        {
            int x = 10;                        //限定变量的声明周期
            System.out.println(x);
        }
        
        Student s1 = new Student();
        System.out.println("---------------");
        Student s2 = new Student("张三",23);
    
    }

    static {
        System.out.println("我是在主方法类中的静态代码块");
    }
}

class Student {
    private String name;
    private int age;

    public Student(){
        //study();
        System.out.println("空参构造");
    }                                    //空参构造

    public Student(String name,int age) {//有参构造
        //study();
        this.name = name;
        this.age = age;
        System.out.println("有参构造");
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    {    //构造代码块:每创建一次对象就会执行一次,优先于构造函数执行
        //System.out.println("构造代码块");
        study();
    }

    public void study() {
        System.out.println("学生学习");
    }

    static {                                    
        System.out.println("我是静态代码块");    
                //随着类加载而加载,且只执行一次
               //作用:用来给类进行初始化,一般用来加载驱动
              //静态代码块是优先于主方法执行
    }
}

class Student {
    static {
        System.out.println("Student 静态代码块");
    }
    
    {
        System.out.println("Student 构造代码块");
    }
    
    public Student() {
        System.out.println("Student 构造方法");
    }
}

class Demo2_Student {
    static {
        System.out.println("Demo2_Student静态代码块");
    }
    
    public static void main(String[] args) {
        System.out.println("我是main方法");
        
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

extends(继承)

让类与类之间产生关系，父子类的关系

class Demo_Animal{
    public static void main(String[] args ) {
        cat c = new Cat();
        c.name = "汽水"
        c.color = "桔色"
        c.eat();
        c.sleep();
        c.play();
        System.out.println("名字：" + c.name );
        System.out.println("颜色：" + c.color );
        System.out.println("在干嘛：" + c.play );
    }
}
class Animal {
        String name;
        String color;
     public void eat() {
       System.out.println("吃饭"); 
    }
     public void sleep() {
       System.out.println("睡觉"); 
    }
     public void play() {
       System.out.println("打豆豆"); 
    }
}    
class Cat extends Animal{ }  
class Dog extends Animal{ }    
/*
extends是继承的意思
Animal是父类
Cat和Dog都是子类
*/     

继承的好处与弊端

好处：

　　提高了代码的复用性

　　提高了代码的维护性

　　让类与类之间产生了关系，是多态的前提

弊端：

　　类的耦合性增强了

开发的原则：高内聚，低耦合

　　耦合：类与类的关系

　　内聚：就是自己的完成某件事情的能力

java中类的继承特点

1，Java只支持单继承，不支持多继承。
2，有些语言是支持多继承，格式：extends 类1,类2,...

Java支持多层继承(继承体系)：子类 ==> 父类 ==> 爷

注：

1，如果想用这个体系的所有功能用最底层的类创建对象
2，如果想看这个体系的共性功能,看最顶层的类

class Demo2_Extends {
    public static void main(String[] args) {
        DemoC d = new DemoC();
        d.show();
    }
}
class DemoA {
    public void show() {
        System.out.println("DemoA");
    }
}

class DemoB extends DemoA {
    public void method() {
        System.out.println("DemoB");
    }
}

class DemoC extends DemoB {
    public void print() {
        System.out.println("DemoC");
    }
}

继承的注意事项

1，子类只能继承父类所有非私有的成员（成员方法和成员变量）

2，子类不能继承父类的构造方法，但是可以通过super关键字去访父类构造方法

3，不要为了部分功能二区继承

继承其实体现的是一中关系：“is a”

假设：如果有两个类A，B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。