2019-05-18 Java学习日记 day8

1.代码块

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

代码块分类：

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

常见代码块的应用：

局部代码块：

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

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

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

静态代码块：

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

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

　　一般用于加载驱动

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("小黑",20);
    }
}

class student
{
    private String name;
    private int age;
    public student(){
    //study();
    System.out.println("空参构造");
    };

    public student(String name,int age){
        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;
    }
    {
        study();
    System.out.println("我是代码块");
    //构造代码块：美创建一次对象就会执行一次，优先于构造函数执行
    }
    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_code
{
    

public static void main (String args []){
       System.out.println("我是主方法");
       student s1=new student();
        student s2=new student();

}
static{
      System.out.println("主方法的静态代码块");//先加载这个
    }
}

2.继承（extends）

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

class demo1_extends
{
    public static void main (String args []){
      cat c=new cat();
      c.color="黑色";
      c.leg=20;
      c.eat();

      animal a=new animal();
      a.seelp();
      a.color="五彩碧蓝的黑色";
    System.out.println(a.color);

     System.out.println(c.color);
    }
}

class animal
{
 String color;
 int leg;
 public void eat(){System.out.println("吃饭");}
 public void seelp(){System.out.println("睡觉");}
}
class cat extends animal          
{

}
class dog extends animal
{

}
/*
animal 是父类
cat和dog都是子类
*/

继承的好处：

　　提高了代码的复用性

　　提高了代码的维护性

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

弊端：

　　类的耦合性增强了

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

　　耦合：类与类的关系

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

继承的特点：

　　java的继承不支持多继承

　　支持多层继承：子<父<爷

class demo2_extends
{
    public static void main (String args []){
    democ c=new democ();
    c.show();
    demob b=new demob();
    b.show();
    }
}
class demoa{
    public void show(){
  System.out.println("demoa");
}
}
class demob extends demoa{
    
}
class democ extends demob{
  
}

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

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

子类有就不用父类

面向对象 this，super

this:代表当前对象的引用，谁来调用我，我就代表谁

super：代表当前对象父类的引用

调用成员变量：

　　this.成员变量 调用本类的成员变量，也可以调用的成员变量

　　super.成员变量 调用父类成员变量

调用构造方法：

　　this（....）调用本类的构造方法

　　super（....）调用父类的构造方法

调用成员方法：

　　this.成员方法 调用本类的成员方法，也可以调用父类的方法

　　super.成员方法 调用父类的成员方法

class demo3_extends
{
    public static void main (String args []){
    son s=new son();
    s.print();
    }
}
class father
{
    int num1=10;
    int num2=20;
}
class son extends father
{
    int num2=30;
    public void print(){
    System.out.println(num1);
    System.out.println(super.num2);
    }
}

class demo4_extends {
    public static void main (String args []){
        son s1=new son();
        System.out.println(s1.getname()+s1.getage());
        System.out.println("-------");
        son s2=new son("张三",20);
        System.out.println(s2.getname()+s2.getage());
    }
}
class father
{
    private String name;
    private int age;
    public father(){
    System.out.println("father 空参构造方法");
    }
    public father(String name,int age){
    this.name=name;
    this.age=age;
    System.out.println("father 有参构造方法");
    }
    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;
    }
}

class son extends father
{
    public son(){
        this("李四",50);
    System.out.println("son 空参构造方法");
    }
    public son(String name,int age){
    super(name,age);
    System.out.println("son y有参构造方法");
    }
}

class fu
{
    public int num=10;
    public fu(){
    System.out.println("fu");
    }
}
class zi extends fu
{
    public int num=20;
    public zi(){
    System.out.println("zi");
    }
    public void show(){
    int num=30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

class demo5_extends
{
    public static void main (String args []){
    zi z=new zi();
    
    z.show();
    }
}

重写

子父类出现了一模一样的方法（返回值可以是子父类）

　　应用：当子类需要父类的功能，而功能主题子类有自己特有内容时，可以重写父类中的方法。

　　　　　　这样，即沿袭了父类的功能，又定义了子类特有的内容

注意事项：

父类中私有方法不能被重写：因为父类私有方法子类基本就无法继承；

子类重写父类方法时，访问权限不能更低：最好一致

父类静态方法，子类也必须通过静态方法进行重写

 方法重写（override）：子类中出现了和父类中方法声明一摸一样的方法，与返回值有关，返回值是一致的（或是子父类）。

 方法重载（overload   ：本类中出现的方法名一样，参数列表不同的方法，与返回值无关。