java之代码块,继承,继承中的构造方法和关键字(this,super,final),重写

一.代码块

种类:

1.局部代码块:{代码}

书写位置:方法中

作用:限制变量的作用域

实例:(不经常这样用)

   public class Kll {
            public static void main(String[] args) {
                {
                    int num = 10;
                    System.out.println("局部代码块");
                }
        }

2.构造代码块

书写位置:类中方法外

调用:1.系统在创建对象时,自动调用;2.在构造方法被调用之前,先被系统调用

作用:每个对象创建出来时,立即执行的某些方法,可以放在构造代码块中(实际上利用了特点:创建对象就会执行构造代码块)

代码例子:

public class Kll {
    public static void main(String[] args) {

        {
            int num = 10;
            System.out.println("局部代码块");
        }

    }
}

3.静态代码块(使用static修饰的代码块)

位置:类中方法外

调用特点:1.随着类的加载而调用(和对象的创建无关);2.只加载一次;3.系统加载类到方法区时自动调用

作用:加载驱动程序,只加载一次(JDBC)

代码例子:

public class Kll {
static {
    System.out.println("main的静态代码块");
}
public static void main(String[] args) {
}

}

4.同步代码块 (多线程部分,后边会讲)

注意:
静态代码块优先于构造代码块执行

代码实例:

public class Kll {
    public static void main(String[] args) {

        /*{
            int num = 10;
            System.out.println("局部代码块");
        }*/
        Person p = new Person();

    }
}
//暴力调试法(打印)
//小黄鸭调试法(调整代码逻辑)
//断点调试
class Person{
    String name;
    //无参构造方法
    public Person() {
        System.out.println("无参");
    }
    //有参构造方法
    public Person(String name) {
        this.name = name;
        System.out.println("有参");
    }
    public void sayHi() {
        System.out.println(name+" ");
    }
    //构造代码块
    {
        System.out.println("构造代码块");
    }
    //静态代码块
    static {
        System.out.println("静态代码块");
    }
}

编译输出结果是:静态代码块 构造代码块 无参

二.继承

面向对象特征:
封装,继承,多态

继承的特点:

1.继承链

2.继承有传递性

3.继承行为和属性

4.建立类和类之间的关系(继承关系)

使用继承的前提条件:

注意:必须符合生活逻辑,才可以使用继承

继承的好处:

1.减少代码量

2.提高工作效率

3.增加代码的复用性

继承的弊端:

高内聚:指一个类的内部方法联系程度

低耦合:类与类之间尽量减少联系

设计模式基本上都是为了解耦(降低耦合度)

写法:关键字 extends

子类 extends 父类

public class Kll {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "加菲猫";
        cat.age = 1;
        cat.sayHi();
        cat.speak();
    }
}
/*
 * 动物类
 * 姓名 年龄
 * 猫类
 * 姓名 年龄 喵喵喵
 * 狗类
 * 姓名 年龄 汪汪汪
 */
class Animal{
    String name;
    int age;
}
class Cat extends Animal{
    public void speak() {
        System.out.println("喵喵");
    }
    public void sayHi() {
        System.out.println(name+" "+age);
    }
}
class Dog extends Animal{
    public void speak() {
        System.out.println("汪汪");
    }
}

判断是不是继承可以看看A是不是B,例如猫是不是动物,不是就不能继承

java中的继承是只允许单继承(类和类之间的关系),多继承体现在接口

java中允许多层继承(继承链)[一层一层继承下去]

比如要使用继承链中 特有的方法 使用哪儿个类好?

一般使用继承链中 末端的类

比如要使用继承链中 共有的方法 使用哪儿个类好?

一般使用继承链中 顶端的类

public class Kll{

    public static void main(String[] args) {
        //java中所有 如果没写继承哪儿个类,默认是继承Object类
        //Object类是所有类的基类
        //直接打印对象 实际上是调用了Object类中的toString()方法
        //思考:toString()方法对你有什么用?
        //可以用重写(后边会讲重写)来写介绍自己的方法,不用再写介绍自己的方法
        KllA a = new KllA();
        System.out.println(a);
    }
}
class KllA{
    String name;
    public void sayHi() {
        System.out.println(name);
    }
}
class KllB extends KLlA{

}
class KllC extends KllB{
    String gender;
}

三.继承中的构造方法

注意:构造方法是不能继承的

继承中的会自动调用(在未手写的情况下)父类的构造方法,是为了保证继承的完整性

代码实例:

public class Kll {
    public static void main(String[] args) {
        //创建son对象
        //无参构造方法创建
        //为什么会调用父类的无参构造方法?
        //保证继承的完整性
        //创建子类对象时,为了保证继承的完整性,会默认调用父类的无参构造方法
        Son s1 = new Son();

        Son s2 =new Son("王健林");
    }
}
class Father{
    String name;
    //无参构造方法
    public Father() {
        super();//表示Father类的父类Object类的对象
        System.out.println("Father类的无参构造方法");
    }
    //有参构造方法
    public Father(String name) {
        this.name = name;
        System.out.println("Father类的有参构造方法");
    }
    //介绍自己的方法
    public void sayHi() {
        System.out.println(name);
    }
}
class Son extends Father{
    //无参
    public Son() {
        //系统会在子类的无参构造方法的第一行,(如果没写会自动)加载父类的无参构造方法
        super();//调用父类的无参构造方法
        System.out.println("son类的无参构造方法");
    }
    //有参
    public Son(String name) {
        System.out.println("son类的有参构造方法");
    }
}

思考:如果父类中没有提供无参的构造方法,怎么办?

说明:该类中一定会有 有参的构造方法(使用super调用有参构造方法)

注意:以后写代码,必须提供一个无参构造方法(无参有参都写)

javaBean规范:

1.成员变量私有化

2.提供set/get方法

3.必须提供无参的构造方法

代码实例:

public class Kll {
}
class Car{
    String name;
    /*public Car() {
        System.out.println("car 无参");
    }*/
    //有参构造方法
    public Car(String name) {
        System.out.println("Car 有参");
    }
}
class Audi extends Car{
//无参构造方法
    public Audi() {
        //可以在构造方法的第一行调用有参的构造方法 来保证继承的完整性
        //只要在子类中 调用父类的构造方法就行(不管有参还是无参)
        super("哈哈");
        System.out.println("Audi 无参");
    }
    //有参构造方法
    public Audi(String name) {
        super("哈哈");
        System.out.println("Audi 有参");
    }
}

四.关键字(this,super,final)

1.this和super

this:
类中表示 本类的对象

继承中 this属性系统会先从本类中找该属性,找到就输出,

没找到,就去父类中寻找,找到输出,都找不到会报错.

super:
在子类中 表示的是 父类的对象

super:也可以调用父类中的方法

代码例子:

public class Kll {
    public static void main(String[] args) {
        TestB b = new TestB();//创建一个TestB对象
        b.fun();
    }
}
class TestA{
    int number1 = 10;
    int number2 = 20;
}
class TestB extends TestA{
    int number2 = 30;
    public TestB(){
    //根据就近原则打印的是本类的number1
        System.out.println(number1);
    }
    public void fun() {
    //打印的是本类的变量
        System.out.println(this.number1);
        System.out.println(this.number2);
        //这里super表示父类的对象(即打印父类的number2)
        System.out.println(super.number2);
    }
}

2.final

关键字 final()

1.修饰变量 变量不能更改(相当于把变量变成了常量)

2.修饰方法 方法不能被重写

3.修饰类 该类不能被继承

代码实例:

public class Kll {
    public static void main(String[] args) {
        //final int a = 10;
        //a = 15;赋值报错是因为该变量有final修饰,变为常量
        // final 引用数据类型,不能修改地址(对象属性可以随意修改)
        final Test t1 = new Test();
        t1.name = "哈哈";
        t1.name = "黑";
    }
}
class Test3{
    //声明静态常量
    //命名规范:所有单词使用大写,多个单词使用下划线连接

    public final int MAX_VALUE;//无效值(系统分配的初始值),所以会报错
    String name;
    //可以使用构造方法或者构造代码块进行赋值就不会报错
    public Test3() {
        MAX_VALUE = 10;
    }
    /*
      {
        MAX_VALUE = 10;
      }
     */
    public void fun1() {

    }
}
class Test4 extends Test3{
    public void fun() {

    }
}

五.重写

方法的重载和重写

方法的重载(Overload)

前提:方法都在一个类,可以使用重载

当方法的功能相同,但是内部实现不同,可以使用重载

方法的重写(Override)

前提:类与类之间必须建立继承的关系

作用:相当于对原方法功能上的一个提升

写法:方法和父类完全一致,才是方法的重写

public class Kll {
    public static void main(String[] args) {
        //Test2 t1 = new Test2();
        //t1.fun();
        IOS8 ios8 = new IOS8();
        ios8.Siri();
        //意愿:直接输出对象时,希望可以把该对象的所有成员变量打印出来
        System.out.println(ios8);
    }
}
class Test1{
    public void fun() {
        System.out.println("Test1的fun方法");
    }
}
class Test2 extends Test1{
    //重写fun方法
    public void fun() {
        //可以在重写方法中,调用父类的原方法
        //可以让功能进行升级
        System.out.println("Test2的fun方法");
    }
}

class IOS7{
    String name = "kll";
    String color = "亮红色";
    //方法
    public void Siri() {
        System.out.println("English");
    }

}
class IOS8 extends IOS7{
    @Override //注解 标识下列方法 是重写父类的方法
    public void Siri() {
        super.Siri();
        System.out.println("Chinese");
    }
    //重写Object类中的toString方法
    //可以代替之前的介绍自己的方法 来输出对象的所有属性
    @Override//注解 标识下列方法 是重写父类的方法
    public String toString() {
        return "name是:"+name+"\tcolor是:"+color;
    }

}