day08

08.01 面向对象（代码块的概述和分类）
  A.代码块概述
　　在Java中，使用{}括起来的代码被称为代码块
  B.代码块分类
　　根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块（多线程讲解
  C.常用代码块的应用
　　a.局部代码块
　　　　在方法中出现：限定变量声明周期，及早释放
　　b.构造代码块
　　　　在类中方法外出现：多个构造方法中相同的代码存放在一起，每次调用，构造都执行，并且在构造方法之前执行
　　　　如果我们想在每一个方法中调用study（）方法，可以将其调用方式写道构造代码块里面

public class day08_01 {
    //如果我们想在每一个方法中调用study（）方法，可以将其调用方式写道构造代码块里面
    public static void main(String[] args) {
        {
            int x =10;           //限定变量的声明周期
            System.out.println(x);
        }
        Student s1 = new Student();    //空参

        Student s2 = new Student("张三",23);
    }

}
class Student{
    private String name;
    private int age;
    
    public Student(){
        //study()
        System.out.println("我是空参");
    }
    public Student(String name,int age){
        //study()
        System.out.println("我是有参");
        this.name = name;
        this.age = age;
    }
    //
    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("学生学习");
    }
}

　　c.静态代码块
　　　　在类中方法外出现，加了static修饰
　　　　在类中方法外出现，并加上static修饰，用于始类进行初始化，在加载的时候就执行，只执行一次

public class day08_01 {
    //如果我们想在每一个方法中调用study（）方法，可以将其调用方式写道构造代码块里面
    public static void main(String[] args) {
        {
            int x =10;           //限定变量的声明周期
            System.out.println(x);
        }
        Student s1 = new Student();    //空参

        Student s2 = new Student("张三",23);
    }

}
class Student{
    private String name;
    private int age;
    
    public Student(){
        //study()
        System.out.println("我是空参");
    }
    public Student(String name,int age){
        //study()
        System.out.println("我是有参");
        this.name = name;
        this.age = age;
    }
    //
    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("我是静态代码块");
    }
}

　　一般用于加载驱动

08.03 面向对象（继承案例演示）
  A.继承（extend）
　　类与类之间，子父类
  B.继承案例演示
　　动物类，猫类，狗类
　　定义两种属性（颜色，腿的个数）
  C.案例演示
　　继承狗
  D.案例演示
　　使用继承后

public class day08_03 {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.color = "flower";
        c.leg =4;
        c.eat();
        c.sleep();
        System.out.println(c.leg + "..." + c.color);
    }

}
class Animal{
    String color;
    int leg;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉的功能");
    }
}
class Cat extends Animal{
    
}
class Dog extends Animal{
    
}

08.04 面向对象（继承的好处和弊端）
  A.继承的好处
　　a.提高了代码的复用性
　　b.提高了代码的维护性
　　c.让类与类之间产生了关系，是多态的前提
  B.继承的弊端
　　类的耦合性增强了
　　开发的原则：高内聚，低耦合
　　　　耦合：类与类的关系
　　　　内聚：就是自己完成某件事的能力

08.05 面向对象（继承的特点）
  A .Java中类的继承特点
　　a.Java只支持单继承，不支持多继承（一个儿子只有一个爸）
　　b.java支持多层继承
  B.案例演示
　　Java继承特点
　　如果想用这个体系的所有功能用最底层的类创建对象
　　如果想看这个体系的共性功能，看最顶层的类

//多层继承，不能多继承
public class day08_005 {
    public static void main(String[] args) {
        DemoC c = new DemoC();
        c.show();
    }

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

08.06 面向对象(继承中构造方法的关系)
  A.继承的注意事项
　　a.子类不能继承父类的私有方法
　　b.子类不能继承父类的构造方法
　　c.不要为了部分功能而去继承
　　　　项目经理 姓名 工号 工资 奖金
　　　　程序员 姓名 工号 工资
  B.什么时候使用继承
　　继承其实体现的是一种继承关系：“is a”
08.07 面向对象()
  A.案例演示
　　a.不同名的变量
　　b.同名的变量
08.08 面向对象(this和super的区别和应用）
  A.this和super都代表了什么
　　this 代表当前对象的引用，谁来调用我，我就代表谁
　　super 调用当前父类的引用
  B.this和super的区别
　　a.调用成员变量
　　　　this.成员变量 调用本类的成员变量，可以调用父类的成员变量
　　　　super.成员变量 调用父类的成员变量
　　b.调用构造方法
　　　　this(...) 调用本类的构造方法
　　　　super(...) 调用父类的构造得到
　　c.调用成员方法
　　　　this.成员方法 调用本类的成员方法，可以调用父类的方法
　　　　super.成员方法 调用父类的成员方法

public class day08_07 {
    public static void main(String[] args){
        Son1 s = new Son1();
        s.print();
    }
}
/*A.案例演示
    a.不同名的变量
    b.同名的变量*/
class Father1{
    int num1 =10;
    int num2 = 30;
}
class Son1 extends Father1{
    int num2 = 20;              //同名的变量，，就近原则
    
    public void print(){
        System.out.println(this.num1);   //this可以调用子类的，也可以调用父类的
        System.out.println(num2);
        System.out.println(super.num2);  //super调用父类的
    }
}

08.09 面向对象(继承中构造方法的关系)

  A.案例演示
　　子类中所有的构造方法默认都会访问父类中空参的构造方法
  B.为什么呢？
　　因为子类会继承父类中的数据，可能还会使用父类的构造方法
　　所以，子类初始化之前，一定要先完成父类数据的初始化
　　其实：
　　　　每一个构造方法的第一条语句默认都是：super（）在这里简单提一句，object类，

public class day08_09 {
    //子类中所有的构造方法默认都会访问父类中空参的构造方法 
    public static void main(String[] args) {
        Son9 s = new Son9();
        
    }

}
class Father9{
    public Father9(){
        System.out.println("Father构造方法");
    }
}
class Son9 extends Father9{    //子类继承父类
    public Son9(){
//        super();               //隐藏该语句，用来访问父类中的空参构造
        System.out.println("Son的构造方法");
    }
}

运行结果：
 Father构造方法
 Son的构造方法

08.10 面向对象(继承中构造方法的注意事项)
  A.案例演示
　　父类没有无参构造方法,子类怎么办
　　　　super()
　　　　this()
  B.注意事项
　　super(...)或者this(...)

public class day08_10 {
    /*   A.案例演示
              父类没有无参构造方法,子类怎么办
                  super()
                  this()        
     */
    public static void main(String[] args) {
        Son10 s1 = new Son10();
        System.out.println(s1.getName()+"..."+s1.getAge());
        System.out.println("----------------");
        Son10 s2 = new Son10("张三",23);                           //第1部
        System.out.println(s2.getName()+"..."+s2.getAge());    //第5部
    }
}
class Father10{
    private String name;                                        //第4部
    private int age;
    //2.空参，有参构造方法
    public Father10(){     //此处隐藏了super（），先输出父类空参构造
        System.out.println("Father空参构造");
    }
    public Father10(String name,int age){                        //第3部
        this.name = name;
        this.age=age;
        System.out.println("Father有参构造");
    }
    //set,get方法
    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;
    }
}
//子继承父
class Son10 extends Father10{
    public Son10(){
        //super("王五",25);                //调用父类的构造方法
        this("王五",25);                 //调用本类的构造方法，就是下面的有参构造Son10(String name,int age)
        System.out.println("Son 空参构造");
    }
    public Son10(String name,int age){                           //第2部
        super(name,age);                        //super进行访问
        System.out.println("Son 有参构造");
    }
}

运行结果：
Father有参构造
Son 有参构造
Son 空参构造
王五...25
----------------
Father有参构造
Son 有参构造
张三...23

08.11 面向对象（继承中的面试题）

class day08_11 {
    public static void main(String[] args){
        Zi z = new Zi();
        z.show();
    }
}
class Fu{
    public int num = 10;
    public Fu(){      //调用该构造方法是隐藏super（）
        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);
    }
}

运行结果是：
隐藏了super（）方法
fu
zi
30
20
10

/*
 1.jvm调用了main方法，main进栈
 2.遇到Zi22 z = new Zi22();会将Fu.class和Zi.class分别加载进内存，再创建对象，当Fu.class加载进内存
     父类的静态代码块会随着Fu.class一起加载，当Zi.class加载进内存，子类的静态代码块会随着Zi.class一起加载
     第一个输出，静态代码块Fu，第二个输出，静态代码块Zi
 3.走Zi类的构造方法，因为Java中是分层初始化的，先初始化父类，再初始化子类，先走父类构造，但在执行父类构造时，发现，父类有构造代码块，构造代码块是
    优先于构造方法执行，第三个输出构造代码块Fu,第四个输出构造代码块Zi
 4.Fu类初始化结束，子类初始化，第五个是构造代码块zi,构造方法*/
public class day08_12 {
    public static void main(String[] args) {
        Zi22 z = new Zi22();
    }
}
class Fu22{
    static{
        System.out.println("静态代码块Fu");
    }
    {
        System.out.println("构造代码块Fu");
    }
    public Fu22(){
        System.out.println("构造方法Fu");
    }
}
class Zi22 extends Fu22{
    static{
        System.out.println("静态代码块Zi");
    }
    {
        System.out.println("构造代码块Zi");
    }
    public Zi22(){
        System.out.println("构造方法Zi");
    }
}

08.12 面向对象(继承中成员的方法关系)
A.案例演示
　　a.不同名的方法
　　b.同名的方法

/*
A.案例演示
      a.不同名的方法
      b.同名的方法*/
public class day08_12 {
    public static void main(String[] args) {
        Son12 a = new Son12();
        a.print();
        a.method();
    }
}
class Father12{
    public void print(){
        System.out.println("Fu print");
    }
}
class Son12 extends Father12{
    public void method(){
        System.out.println("Zi print");
    }
    public void print(){               //子父类出现相同的方法
        super.print();                    //如果还想调用父类的方法，用super.方法名进行调用
        System.out.println("Zi print");
    }
}
运行结果：
Fu print
Zi print
Zi print

08.13 面向对象(继承中成员方法关系)
  A.什么是方法重写
　　重写:子父类出现了一模一样的方法
  B.方法重写的应用
　　当子类需要父类的功能,而子类又有自己的特点,可以重写父类的方法
  C.案例演示
　　定义一个手机类

public class day08_13 {
    public static void main(String[] args) {
        IOS8 i =new IOS8();
        i.siri();
        i.call();          //直接调用父类的方法
    }

}
class IOS7{
    public void call(){
        System.out.println("call Phone");
    }
    public void siri(){
        System.out.println("speak English");
    }
}
class IOS8 extends IOS7{
    public void siri(){
        System.out.println("speak Chinese");
        super.siri();     //调用父类的
    }
}

08.14 面向对象(方法重写的注意事项)
  A.方法重写注意事项
　　a.父类中私有方法不能被重写
　　　　因为父类私有方法子类根本无法继承
　　b.子类重写父类方法时,访问权限不能更低
　　　　最好一致
　　c.父类静态方法,子类也必须通过静态方法进行重写
　　　　其实算不上方法重写,但是现象的确如此,至于为什么算不上,多态会讲
  B.案例演示
08.15 面向对象(方法重写的面试题)
  A.方法重写的面试题
　　override和overload的区别
　　overload可以改变返回值类型,只看参数列表
　　override,子类出现了和父类中方法声明一模一样的方法,与返回值有关,返回值必须是一致的

08.16 面向对象（使用继承前的学生和老师案例）
  A.案例演示
　　使用继承前的学生和老师案例
　　　　属性：姓名 年龄
　　　　行为：吃饭
　　老师有特有的方法：讲课
　　学生有特有的方法：学习

public class day08_16 {
    public static void main(String[] args) {
        Student16 s1 =new Student16();            //调用的时空参构造，进行赋值
        s1.setName("张三");
        s1.setAge(23);
        System.out.println(s1.getName()+"..."+s1.getAge());
        s1.eat();
        s1.study();
        System.out.println("-------------------");
        Student16 s2= new Student16("李四",24);
        System.out.println(s2.getName()+"..."+s2.getAge());
        s2.eat();
        s2.study();
    }
}
/*属性：姓名 年龄
    行为：吃饭
    老师有特有的方法：讲课
    学生有特有的方法：学习*/
class Person{
    private String name;
    private int age;
    //空参，有参构造
    public Person(){}
    public Person(String name,int age){    
    }
    //set，get
    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("eat");
    }
    public void study(){
        System.out.println("study");
    }
}
class Student16 extends Person{
    public Student16(){
    }
    public Student16(String name,int age){
        super(name,age);
    }
    public void study(){
        System.out.println(this.getName()+"student study");  //this.getName()调用父类的变量
    }
}
class Teacher extends Student16{
    public Teacher(){}
    public Teacher (String name,int age){
        super(name,age);
    }
    public void teach(){
        System.out.println("teach");
    }
}

08.17 面向对象（使用继承前的学生和老师案例）
  A.案例演示
　　使用继承前的学生和老师案例
　　　　属性：姓名 年龄
　　　　行为：吃饭
　　　老师有特有的方法：讲课
　　　学生有特有的方法：学习

public class day08_18 {
    public static void main(String[] args) {
        Cat18 c1 = new Cat18("花",4);
        System.out.println(c1.getColor() + "..." +c1.getLeg());
        c1.eat();
        c1.catchMouse();
        Dog18 d1 = new Dog18();
        System.out.println(d1.getColor()+"..."+d1.getLeg());
        d1.eat();
        d1.lookhouse();
    }
}
class Animal18{
    private String color;
    private int leg;
    //
    public Animal18(){}
    public Animal18(String color, int leg){
        this.color = color;
        this.leg = leg;
    }
    //
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public int getLeg() {
        return leg;
    }
    public void setLeg(int leg) {
        this.leg = leg;
    }
    //
    public void eat(){
        System.out.println("eat");
    }
}
class Cat18 extends Animal18{
    public Cat18(){}
    public Cat18(String color,int leg){
        super(color,leg);
    }
    public void eat(){
        System.out.println("Cat eat fish");
    }
    public void catchMouse(){
        System.out.println("catch mouse");
    }
}
class Dog18 extends Animal18{
    public Dog18(){}
    public Dog18(String color,int leg){
        super(color,leg);
    }
    public void eat(){
        System.out.println("Cat eat fish");
    }
    public void lookhouse(){
        System.out.println("catch mouse");
    }
}

08.18 面向对象（猫狗案例分析，实现及测试）
  A.猫狗案例分析
  B.案例演示
　　猫狗案例继承版
　　　　属性：猫的颜色，腿的个数
　　　　行为：吃饭
　　猫特有的行为：抓老鼠catchMouse
　　狗特有的行为：看家 look Home
08.19 面向对象（final关键字修饰类，方法以及变量的特点）
  A.final概述
  B.final修饰特点
　　修饰类，类不能被继承
　　修饰变量，变量就变成了常量，只能被赋值一次
　　修饰方法，方法不能被重写
 C.案例演示
　　final修饰特点
08.20 面向对象（final关键字修饰局部变量）
  A.案例演示
　　方法内部或者方法声明上都演示一下
　　基本类型,是值不能被改变
　　引用类型,是地址不能被改变,对象中的属性可以改变
08.21 面向对象(final修饰变量的初始化时机)
  A.final修饰变量的初始化时机
  B.案例演示
08.22 zongjie