8、面向对象（代码块、继承方法、重写与方法重载的区别、final关键字）

回顾：

a.构造方法：用来进行类的实例化，也就是说你要创建对象，必须借助构造方法，才能完成类的实例化。
b.构造方法：方法名和类名相同，没有返回值类型，void也没有。我们自定义的类，默认会存在一个空参的构造方法。
c.当然你可以手动提供有参构造，但是一旦你手动提供了有参构造，默认的无参就不存在了，你如果还想用无参构造。来创建对象，建议手动给出无参构造。
d.一个类的构成：构造方法，成员变量，成员方法。
e.static:静态的，可以修饰成员变量，和成员方法。
f.static 修饰成员变量，此变量为共享变量，可以被该类的所有对象，所共享。
g.被静态所修饰的，是随着类的加载而加载 xxx.class 这个字节码文件一加载进内存，静态的数据就会加载，静态的是优先于对象而存在的。
h.在静态方法里面，只能访问静态成员，无法访问非静态成员。在静态方法里面，不存在this关键字
静态成员属于类，推荐使用类名调用

1、代码块的概述和分类

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

 代码块分类
    根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块

 常见代码块的应用
    a:局部代码块 
        在方法中出现；限定变量生命周期，及早释放，提高内存利用率
    b:构造代码块 
        在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
    c:静态代码块 
        在类中方法外出现，加了static修饰
        在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

 

public class Haha {
    static int num=10;
    {
        System.out.println("这是构造代码块，定义在类中方法外，和构造方法平级");
    }
    static{
        System.out.println("这是静态代码块");
        System.out.println("定义在类中方法外，用static所修饰,经常在静态代码块里面做一些初始化的准备工作");
        System.out.println(num);
    }

    public Haha() {
        System.out.println("空参构造");
    }
}

public class MyTest {
    public static void main(String[] args) {
        //创建对象时，会调用构造代码块，而且还是优先于构造方法执行。每次创建对象，都会调用构造代码块。
        //静态代码块，随着类的加载而加载，优先于构造代码块执行。且只会执行一次。在静态代码块里面，只能访问静态成员。
        Haha a = new Haha();
        Haha b = new Haha();
    }
}

 

2、代码块面试题

//看程序写结果
class Student {
    static {
        System.out.println("Student 静态代码块");  //3
    }
    {
        System.out.println("Student 构造代码块");//4、6
    }
    public Student() {
        System.out.println("Student 构造方法");//5、7
    }
}

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

 

3、继承的概述

继承概述
    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可

继承格式
    通过extends关键字可以实现类与类的继承
    class 子类名 extends 父类名 {}  
    单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类

面向对象的三大特征：封装（class） 继承 多态
Java中的继承 ：子类可以继承父类的成员。
可以使用 extends 关键字，可以让类和类之间形成父子关系。
继承的好处：可以提高代码的复用性和维护性。
继承的思想：把多个子类的共性内容，向上抽取到父类当中，以实现代码的复用性和维护性。
继承的弊端：让类和类之间产生了关系，增加了耦合性。
软件设计原则中：高内聚（某个事物独立完成功能），低耦合

 

4、继承案继承的好处和弊端

 继承的好处
    a:提高了代码的复用性
    b:提高了代码的维护性
    c:让类与类之间产生了关系，是多态的前提

 继承的弊端
    类的耦合性增强了。
    开发的原则：高内聚，低耦合。
    耦合：类与类的关系
    内聚：就是自己完成某件事情的能力

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name="喵喵";
        cat.age=5;
        System.out.println("猫:"+cat.name+"\t"+cat.age);
        cat.eat();
        cat.sleep();
        cat.zhalaoshu();

        Dog dog = new Dog();
        dog.name="大黄";
        dog.age=6;
        System.out.println("狗:"+dog.name+"\t"+dog.age);
        dog.eat();
        dog.sleep();
        dog.kanmen();
    }
}

class Animal{
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

 class Cat extends Animal{
    public void zhalaoshu() {
        System.out.println("抓老鼠");
    }
 }

 class Dog extends Animal{
    public void kanmen(){
        System.out.println("看门");
    }
 }

 

5、Java中类的继承特点

Java中类的继承特点
    a:Java只支持单继承，不支持多继承。
    b:Java支持多层继承(继承体系)
    c:Object 是所有类的顶层父类，所有类都是直接或间接继承自他
    d: 构造方法不参与继承。当我们创建子类对象时，会先调用父类的构造方法，来完成父类数据            的初始化。
    e:父类私有的成员，子类不能继承。

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println(zi.a);
        System.out.println(zi.b);
        //zi.bb();
        //zi.cc();
        //zi.fu();
    }
}

class A extends Object{
    int a=100;
    private int bb=20;
}

class Fu extends A{
    int b=20;
    private double cc=3.14;
    private void fu(){
    }
}

class Zi extends Fu{
}

 

6、继承的注意事项和什么时候使用继承

继承的注意事项
    a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
    b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
    c:不要为了部分功能而去继承

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

7、继承中成员变量的关系

当子类中的成员变量和父类中的成员变量名称一样时
    在子类中访问一个变量的查找顺序("就近原则")
        a: 在子类的方法的局部范围找,有就使用
        b: 在子类的成员范围找,有就使用
        c: 在父类的成员范围找,有就使用
        d:如果还找不到,就报错

8、this和super的区别和应用

this和super的区别
    this    代表的是本类对象的引用
    super  代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)

 this和super的使用
    a:调用成员变量
        this.成员变量          调用本类的成员变量
        super.成员变量       调用父类的成员变量
    b:调用构造方法
        this(...)                    调用本类的构造方法
        super(...)                调用父类的构造方法
    c:调用成员方法
        this.成员方法          调用本类的成员方法
        super.成员方法       调用父类的成员方法

public class Father {
    int num = 100;
    double aa =1.1;
    boolean flag=true;

    public void show() {
        System.out.println("父类的show方法");
    }

    public void hehe() {
        System.out.println("父类的hehe方法");
    }
}

public class Son extends Father {
    int num=200;
    double aa=2.2;
    char ch='a';

    public void ziShow(int num){
        /*
        * 变量的访问原则：遵循就近原则，先在局部范围找（方法发内，以及形参） 如果找不到，就去本类的成员范围找（成员变量）
        * 如果本类成员范围没找到，再去父类成员范围找，找到就使用，再找不到就报错。
        * 当局部变量，本类成员变量，父类成员变量重名了，你可以使用 this super 来区分。
        * */
        System.out.println("子类的show方法");
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
        System.out.println(aa);
        System.out.println(super.aa);
        System.out.println(this.aa);
        System.out.println(flag);
        System.out.println(super.flag);
        System.out.println(this.flag);
        System.out.println(ch);
    }
    
    public void haha(){
        this.show(); //父类的这个show()方法被你继承了，相当于是你的了，所以前面加this也可以。
        super.show(); //调用父类的方法
        this.hh(); //调用本类方法
    }

    public void hh(){
        System.out.println("hhhhhhhh");
    }
}

public class MyTest {
    public static void main(String[] args) {
        //this 和 super
        //super:代表父类空间的一个标识，你可以认为是父类的一个引用，使用它可以访问父类的数据。
        //this:代表本类的一个引用，你使用this，那访问的就是本类的数据。
        //访问成员变量
        //this.成员变量  this.num
        //super.成员变量  super.num
        //访问成员方法：
        // this.成员方法名() this.show()
        // super.成员方法名() super.show()
        // 访问构造方法
        // this()
        // super()

        Son son = new Son();
        son.ziShow(20);
        son.haha();
    }
}

 

9、继承中构造方法的关系

    子类中所有的构造方法默认都会访问父类中空参数的构造方法，为什么呢?
    因为子类会继承父类中的数据，可能还会使用父类的数据。
    所以，子类初始化之前，一定要先完成父类数据的初始化
    其实：
        每一个构造方法的第一条语句默认都是：super()

public class MyTest {
    public static void main(String[] args) {
        Son son = new Son();
    }
}

class Father{
    int num=100;
    public Father() {
        System.out.println("Father父类的空参构造执行了");
    }
}

class Son extends Father{
    int num=20;
    public Son() {
        super();
        System.out.println("son的空参构造执行了"+num+"====="+super.num);
    }
}

 

 

10、继承中构造方法的注意事项

  父类没有无参构造方法,子类怎么办?
    a: 在父类中添加一个无参的构造方法
    b:子类通过super去显示调用父类其他的带参的构造方法
    c:子类通过this去调用本类的其他构造方法
        本类其他构造也必须首先访问了父类构造
注意事项
    super(…)或者this(….)必须出现在第一条语句上

public class MyTest {
    public static void main(String[] args) {
        //当我创建子类对象时，为什么会去先调用父类的空参构造方法，为什么？
        /*
         *  因为子类继承了父类，那也就是说，子类继承了父类的数据，甚至还有去使用父类的数据，
         * 所以当我们创建子类对象时，应该先完成父类数据的初始化，那么子类才能继承父类的数据和使用父类的数据。
         * 既然你要先完成父类数据的初始化，那肯定先要调用父类的构造方法，才能完成父类数据的初始化。
         * 怎么去调用的父类的构造方法呢？其实在每个类的构造方法前面第一行，有一条默认语句  super() 他就去调用父类的空参构造
         * */

        Zi zi = new Zi();
        /*
        *  如果说父类没有提供空参构造呢？
        * //1. 你自己手动提供一个空参构造。
        * //2. 可以调用父类有参构造方法。
        * */
    }
}

class Fu extends Object{
    int num=200;

//    public Fu() {
//        super();
//        System.out.println("父类的构造方法调用了");
//    }

    public Fu(int num){
        System.out.println("父类的构造方法调用了");
        System.out.println(num);
    }
}
class Zi extends Fu{
    int aa=20;
    public Zi() {
        //super();
        //super(10); //调用父类有参构造
        this(20); //调用本类的有参构造
        System.out.println("子类的构造方法调用了");
    }

    public Zi(int num){
        super(num);
        System.out.println("子类的有参构造方法调用了");
    }
}

 

11、继承中的面试题

    看程序写结果1
    class Fu{
        public int num = 10;
        public Fu(){
            System.out.println("fu"); //1
        }
    }
    class Zi extends Fu{
        public int num = 20;
        public Zi(){
            System.out.println("zi"); //2
        }
        public void show(){
            int num = 30;
            System.out.println(num); //30
            System.out.println(this.num); //20
            System.out.println(super.num); //10
        }
    }
    class Test {
        public static void main(String[] args) {
            Zi z = new Zi();
            z.show();
        }
    }
 

 看程序写结果2

class Fu {
		static {
			System.out.println("静态代码块Fu"); //  1
		}

		{
			System.out.println("构造代码块Fu"); //3
		}

		public Fu() {
			System.out.println("构造方法Fu");   //4
		}
	}

	class Zi extends Fu {
		static {
			System.out.println("静态代码块Zi");//2
		}

		{
			System.out.println("构造代码块Zi"); //5
		}

		public Zi() {
			super();
			System.out.println("构造方法Zi"); //6
		}
	}
	
	class Test{
		public static void main(String[] args){
			Zi z = new Zi(); //请问执行结果。
		}
	}

 

12、继承中成员方法关系

当子类的方法名和父类的方法名一样的时候
        通过子类调用方法:
            a: 先查找子类中有没有该方法,如果有就使用
            b: 在看父类中有没有该方法,有就使用
            c: 如果没有就报错

13、方法重写概述及其应用

方法重写
    子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写

方法重写的应用：
    当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
    这样，即沿袭了父类的功能，又定义了子类特有的内容

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show();
    }
}
class Fu{
    public void show(){
        System.out.println("Fu show");
    }
}

class Zi{
    public void show(){
        System.out.println("Zi show");
    }
}

 

14、方法重写的注意事项

方法重写注意事项
    a:父类中私有方法不能被重写
        因为父类私有方法子类根本就无法继承
    b:子类重写父类方法时，访问权限不能更低,最好就一致
    c:父类静态方法，不参与重写
    d:构造方法，不能重写

public class MyTest {
    public static void main(String[] args) {
        //方法重写的注意事项：
        //1.子类在重写父类的方法时，方法的权限修饰符，不能比父类的低，要比父类的高或一样。
        //2. 父类私有的方法，子类不能重写，因为，私有的方法子类都不能继承，何谈重写。
        //3. 构造方法，不能重写，
        //4. 静态方法也不算重写

        Zi zi = new Zi();
        zi.show();
        Zi.hehe();
        Fu.hehe();
    }
}

class Fu {
    public void show() {
        System.out.println("fu show");
    }
    public static  void hehe(){
        System.out.println("父类静态方法");
    }
}

class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("zi show");
    }

    //@Override
    public static void hehe() {
        System.out.println("子类静态方法");
    }
}

 

15、final关键字概述

由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况java就给我们提供了一个关键字: final

 final概述
    final关键字是最终的意思，可以修饰类，变量，成员方法

 

16、final关键字修饰类,方法以及变量的特点

 final修饰特点
    修饰类:        被修饰类不能被继承
    修饰方法:    被修饰的方法不能被重写，可以被子类继承
    修饰变量:    被修饰的变量不能被重新赋值,因为这个量其实是一个常量

    修饰基本类型，是值不能被改变
    修饰引用类型，是地址值不能被改变

public class MyTest {
    public static final int A=100;  //公共的静态常量
    public static void main(String[] args) {
      //  final 最终的，可以修饰变量和方法以及类
        //1. final 修饰变量，此变量为常量 常量名大写。
       final int NUM=20;
        System.out.println(MyTest.A);

        //2.final 修饰方法此方法不能被重写,子类可以继承final 方法，不能重写。
        Zi zi = new Zi();
        zi.show();

        //3. final 修饰类，此类不能被继承
        
        final int a=20;
        //a=30;
        //final 修饰基本数据类型的变量，指的是值不能被改变。

      final Zi zi1 = new Zi();
        //zi1=new Zi();
        //final 修饰引用数据类型的变量，指的是地址值不能被改变。
    }
}

class Fu {
    public final void show(){}
}
class Zi extends Fu{
//public final  void show(){}
}