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

最新推荐文章于 2020-11-26 22:56:06 发布

qq_44725165

最新推荐文章于 2020-11-26 22:56:06 发布

阅读量216

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_44725165/article/details/102551446

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

复习

/* //static 状态修饰符，修饰成员变量，和成员方法，
//被静态所修饰，随着类的加载而加载的
修饰了成员变量，这个变量就是共享变量，被这个类的所有对象，所共享
//被静态所修饰的成员是属于类的，推荐使用类名调用。
//静态方法内部只能访问静态所修饰的成员

//代码块：局部代码块，构造代码块，静态代码块 同步代码块
//局部代码块 定义在方法中 这个范围的代码在执行完被尽早的释放掉
  构造代码块 定义在类的构造为止
  静态代码块 定义在类的构造为止会用static修饰
//静态代码块先执行 只执行一次 静态代码块里面只能调用静态方法或静态变量 
经常在静态代码块里面做一些初始化的工作 类加载的的时候立马就会执行里面的逻辑；
//构造代码块优先于构造方法而执行 在new对象的时候执行 每new一次都会执行一次；  */

代码块

代码块的概述和分类

代码块概述
在Java中，使用{}括起来的代码被称为代码块。
代码块分类
根据其位置和声明的不同，可以分为：局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
常见代码块的应用
a:局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
b:构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
c:静态代码块
在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
局部代码块

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
 //代码块：就是被一对{}大括号所括起来的代码
//代码块根据定义的位置不同分为：局部代码块，构造代码块，静态代码块，同步代码块（后面讲）
        //局部代码块：就是将代码块定义到方法中
        //局部代码块，使用完成之后，可以让资源及早的释放掉//
        
        int b = 20;//在局部代码块外面 定义一个变量b为20
        {
            int a = 10;
            System.out.println("这是局部代码块");
//定义在方法中的 这对{}大括号所括起来的代码 就是局部代码块
            System.out.println(b);
            //在局部代码块里面 访问b 能访问到 因为b作用域比这个局部代码块大一些
        }
        System.out.println(a);//会报错
        //a这个变量的作用域在上面那个局部代码块里面 除了这个作用域a就访问不到了
    }
}

构造代码块

package org.westos.demo;

public class Student {
     int num;
    //构造代码块：定义在类中方法外 和构造方法是一个位置
    {
        System.out.println("构造代码块");
       num=100;//可以在构造代码块里面写一些功能的代码逻辑 这些逻辑比构造方法先调用

    }
    
    }
    public Student() {
        System.out.println("空参构造执行了");
    }

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
//构造代码块什么时候调用?
//当我new创建该类对象时，就可以调用构造代码块，优先于构造方法调用 比构造方法先调用
//构造代码块每一次new创建对象都会调用
        Student student = new Student();
        System.out.println(student.num);//每new一次 都能拿到构造代码块中的100
        Student student1 = new Student();
        System.out.println(student1.num);
        Student student2 = new Student();
        System.out.println(student2.num);
    }
}

静态代码块

package org.westos.demo;

public class Student {
    
    static int num;//
//静态代码块：用static 修饰的代码块———> static{}
//我们一般会在静态代码块里执行一些业务逻辑，比如在类加载的时候，做一些准备工作
//静态代码块里面只能访问静态变量
    static {
        System.out.println("这是一个静态代码块");
        System.out.println(num);
    //如果前面是int num;这里就访问不到了 因为静态只能访问静态 所以改为static int num;
    }
    
    public Student() {
        System.out.println("空参构造执行了");
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
/*    静态代码块，随着类的加载而加载，最早执行（优先于其他代码块和空参构造等）
而且只执行一次---因为字节码文件只执行一次，即Student.class 只进一次内存       */
        Student student = new Student();
        Student student2 = new Student();
        Student student3 = new Student();
    }
}

代码块的面试题

看程序写结果

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();
    }
}

继承

继承的引入和概述

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

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

package org.westos.demo;  //子类
public class Son extends Father{   子类extends父类  
}
//--------------------------------------------------------------------------
package org.westos.demo;  //父类
public class Father {
    int num=100;
    public void show() {
        System.out.println(num);
    }
}
//--------------------------------------------------------------------------
package org.westos.demo;
public class MyTest {
    public static void main(String[] args) {
        //面向对象的三大特征：封装（类），继承，多态
        //生活中的继承：儿子可以继承父亲的财产
        //Java中的继承：子类可以继承父类的数据
        //怎么让一个类跟另一个类产生继承关系 使用一个关键字 extends
        Son son = new Son();
        int num=son.num;   //子类继承了父类的数据
        son.show();   //子类继承了父类的方法

        //继承的优点 可以提高代码的复用性（代码可以少写一些）
    }
}

继承案例演示以及继承的好处和弊端

需求：
学生类和老师类。
定义两个功能(吃饭，睡觉)
案例演示
使用继承前
案例演示
使用继承后
继承的好处
a:提高了代码的复用性
b:提高了代码的维护性
c:让类与类之间产生了关系，是多态的前提
继承的弊端
类的耦合性增强了。
开发的原则：高内聚，低耦合。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "汤姆";
        cat.age = 2;
        System.out.println(cat.name);
        System.out.println(cat.age);
        cat.eat();
        cat.sleep();
        cat.catcheMouse();
    System.out.println("------------------");
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.age = 4;
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.eat();
        dog.sleep();
        dog.lookDoor();
    }
}
class Animal {  
/*   将Cat类 Dog类 String name; int age; 这种多个子类共性的东西定义到父类Animal中
子类就不用再写了   ；   子类中个性的东西不能抽取到父类     */
    String name;
    int age;
    
    public void eat() {
        System.out.println("吃饭饭");
    }
    public void sleep() {
        System.out.println("睡觉觉");
    }
}
class Cat extends Animal {
    public void catcheMouse() {
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal {
    public void lookDoor() {
        System.out.println("看门");
    }
}

Java中类的继承特点

Java中类的继承特点
a:Java只支持单继承，不支持多继承。
有些语言是支持多继承，格式：extends 类1,类2,…
b:Java支持多层继承(继承体系)

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

继承的注意事项
a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
b:子类不能继承父类的构造方法，但是可以通过super(待会儿讲)关键字去访问父类构造方法。
c:不要为了部分功能而去继承
什么时候使用继承
继承其实体现的是一种关系：“is a” .
采用假设法：
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
//继承：子类可以继承父类的成员
//继承：将多个子类的共性，向上抽取到父类当中，以实现代码的复用性和维护性。
//继承的弊端：让类跟类之间产生了关系，增加了耦合性
//软件开发一个原则：高内聚，低耦合
//高内聚：一个类 独立完成某个功能
//耦合：一个类 完成功能依赖于其他类

//继承的注意事项：1.Java中继承只支持单继承 一个类只能有一个父类 但是支持多层继承(儿子继承爸爸继承爷爷)
//2.子类不能继承父类私有的成员
//3.构造方法不参与继承，父类构造方法，用于 子类初始化父类的成员
//4.不要为了继承而继承（不要为了父类的少部分功能 继承父类的所有功能 这样会增加耦合性）
//5.继承体现的是一种 is a 关系 （将子类的共性功能抽取到父类当中）
        C c = new C();
        int num = c.num;//能访问爷爷
        int b = c.b;//能访问爸爸
        c.aa();
       // c.show(); 父类私有方法 子类访问不到
    }
}
class A{
    int num=100;
    private int a=10;  //private：A的私有变量 B和C都访问不到

    public void aa() {
    }
    private void show() {   //private：A的私有方法 之类B和C都访问不到
    } 
}
class B extends A{
    int b=1000;
}
class C extends B{
    int c=2;
}

继承中成员变量的关系

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

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show(1);
//变量访问遵循就近原则
//一个方法中要访问的变量，会先在局部找（方法内或形参）如果找到就使用，如果没找到，就去本类的成员位置找，找到就使用
//如果本类成员位置没找到，就去父类成员位置找，找到就使用，最后都找不到，那就报错
    }
}

class Fu{
    int num=1000;
    int b=1;
}

class Zi extends Fu{
    int num = 10;
    int c=20;
    public void show(int num){
        System.out.println(num); //1 //打印的是 public void show(int num) 中被调用的show方法的num
        System.out.println(this.num); //10 //this调用本类的成员变量
        System.out.println(super.num); //1000//super子类局部范围访问父类成员变量
    }
}

this和super的区别和应用

通过问题引出super
子类局部范围访问父类成员变量
说说this和super的区别
this 代表的是本类对象的引用
super代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)
this和super的使用
a:调用成员变量
this.成员变量调用本类的成员变量
super.成员变量调用父类的成员变量
b:调用构造方法
this(…) 调用本类的构造方法
super(…) 调用父类的构造方法
c:调用成员方法
this.成员方法调用本类的成员方法
super.成员方法调用父类的成员方法
注意：b，c马上讲

         * super：代表父类空间的标识，你可以理解为父类的一个引用，通过super 可以访问父类的数据
         * super.成员变量名//访问父类变量
         * super.成员方法名//访问父类方法
         * super() //访问父类的空参构造
         * super(参数) //访问父类的有参构造
         
         * this:代表本类的一个引用，通过它可以访问本类的数据
         * this.成员变量名//访问本类变量
         * this.成员方法名//访问本类方法
         * this() //访问本类空参构造
         * this(参数) //访问本类有参构造

继承中构造方法的关系

案例演示
子类中所有的构造方法默认都会访问父类中空参数的构造方法
为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。

其实：
每一个构造方法的第一条语句默认都是：super()
在这里简单的提一句，Object类。否则有人就会针对父类的构造方法有疑问。Object在没有父类了。

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
    /*     当我们在创建子类对象时，会先初始化父类，为什么？
//因为我们子类要去继承父类的一些数据，甚至还要去使用它，
那如果父类没有先于子类完成对象父类数据的初始化，子类怎么去继承使用，
所以说，我们在创建子类对象时，先要完成父类数据的初始化，所以说先要调用父类的构造，完成父类数据的初始化
//起始在每个类的构造方法中的第一行，有一条默认语句在调用父类的空参构造  super();      */
        Son son = new Son();//先打印"父类的空参构造" 再打印"子类的空参构造"
    }
}

class Father{
    int num=100;
    public Father() {
        super();//默认语句 不写也存在 //调用父类的空参构造
        System.out.println("父类的空参构造");
    }
}

class Son extends Father{
    public Son() {
        super();//默认语句 不写也存在 //调用父类的空参构造
        System.out.println("子类的空参构造");
    }
}

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

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

package org.westos.demo;

public class Test {
    public static void main(String[] args) {
        Son son = new Son(90);
        System.out.println(son.num);//打印90

        Son son1 = new Son();
        System.out.println(son1.num);
//假如父类没有空参构造，   我们在创建子类对象时，默认访问父类空参构造，   就访问不到，那么我们可以访问父类有参构造

    }
}

class Father{
    int num=900;
    
    public Father(int num) {
        this.num = num;
    }
}

class Son extends Father{

    public Son() {
        this(10);//this调用本类有参 即public Son(int num){}里的num
      //super()和this()：在一个构造方法里面只能有一个  不能共存

    }

    public Son(int num) {
      super(num);
//super(num)如果变成super();就会报错 因为父类没有空参构造 super()访问不到父类的空参构造 即不能初始化父类的数据 
//又因为父类现在存在有参构造 所以加num变为super(num)访问父类的有参构造
    }
}

继承中的面试题

案例演示
看程序写结果1

class Fu {
    public int num = 10;

    public Fu() {
        System.out.println("fu");//fu
    }
}

class Zi extends Fu {
    public int num = 20;

    public Zi() {
        System.out.println("zi");//zi
    }

    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

package org.westos.demo;

public class Test {
    public static void main(String[] args) {
        //当我们new创建子类对象时，父类字节码文件，先加载进内存
        Zi zi = new Zi();
//父一进 静态父子立马执行 
//当在new自己子类时 肯定先初始化父类 依次执行父类构造代码块和构造方法 紧接着执行自己的构造代码块和构造方法       
    }
}

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() {
        System.out.println("构造方法Zi"); //6
    }
}

继承中成员方法关系

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

方法重写与方法重载的区别

方法重写概述及其应用

什么是方法重写
子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。
Override和Overload的区别?Overload能改变返回值类型吗?
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。

package org.westos.demo;
public class Fu {
    public void show(){
        System.out.println("fu Show");
    }
}

package org.westos.demo;
public class Zi extends Fu {
    @Override //注解：可以检测这个方法是不是重写父类的方法//如果在方法前加上@Override不报错 就说明此方法是重写的
    public void show() {
        System.out.println("zi Show");
    }
    //在这里加@Override会报错 因为后面的不属于方法重写
    public void test(){
        System.out.println("子类特有的方法");
    }
}

package org.westos.demo;
public class MyTest {
    public static void main(String[] args) {
        //方法重写：当子类出现了和父类一模一样的方法（方法名相同，返回值类型相同，参数列表相同）
        //那么就会发生子类方法覆盖父类方法的现象，我们称这种现像叫方法重写
        //为什么要有方法重写 就是子类对父类的方法实现不满意，或者说想要对父类方法进行扩展，就可以使用方法重写
        Zi zi = new Zi();
        zi.show();//方法重写后 会打印zi Show 而不是fu Show
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        Cat cat = new Cat();
        cat.eat();

    }
}

class Animal{
    public void eat(){
        System.out.println("eat");
    }
}

class Dog extends Animal{

    public void lookDoor(){
        System.out.println("看门");
    }

    @Override  //方法重写快捷键 ctrl+o//对父类功能不满意 进行方法重写
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

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

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Phone.sendMsg();
        Iphone iphone = new Iphone();
        iphone.call();
        iphone.sendMsg();//打印 发彩信
        Iphone.sendMsg();
    }
}

class Phone{
    public void call(){
        System.out.println("打电话");
    }
    public static void sendMsg(){ //static静态修饰的方法
        System.out.println("发短信");
    }
    protected void show(){}
}

class Iphone extends Phone{
  //ctrl+O 重写父类方法 //对父类功能扩展 进行方法重写
    @Override
    public void call() {
       super.call();
        System.out.println("视频聊天");
    }

    //@Override时报错 因为静态方法不能重写 下面这个方法并不是重写父类的
    public static void sendMsg() {
        System.out.println("发彩信");
    }

    @Override
    public void show(){}//重写父类的protected 不能比protected低 要么高 要么一样
}

方法重写的注意事项

方法重写注意事项
a:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
b:子类重写父类方法时，访问权限不能更低最好就一致
c:父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解

子类重写父类方法的时候，最好声明一模一样。

重写的注意事项
        1.父类私有的方法，子类不能重写，因为私有的方法，子类都不能继承，何谈重写
        2.静态方法，不参与重写,静态方法算不上重写
        3.子类在重写父类方法时，方法前面的权限修饰符，不能比父类的低，要么比父类的高，或者跟父类一样,最好一样
           public >protected>缺省的>private

final关键字继承

final关键字概述

为什么会有final
由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况java就给我们提供了一个关键字: final
final概述
final关键字是最终的意思，可以修饰类，变量，成员方法。

package org.westos.demo;

public class MyTest {
    public static final int A=100; //公共的静态常量
    public static void main(String[] args) {
        //final 最终的，可以修饰变量，成员方法，类
        //final 修饰变量，这个变量成为常量
        //final 修饰方法，子类不能重写，只能继承
        //final 修饰类，此类不能被继承        
       final int NUM=100; //final修饰，属于 自定义常量，常量的命名规范是 字母全部大写
        System.out.println(NUM);

        int a = MyTest.A;

        new Zi().show();
    }
}

class Fu{
    public final void show(){   //final 修饰方法，子类不能重写，只能继承
        System.out.println("父类的final方法");
    }
}

class Zi extends Fu{
}

final class B{   //final 修饰类，此类不能被继承
}

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

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

final关键字修饰局部变量

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

   final int num=10;
     // num=20 就不能再赋值了 //基本类型，是值不能被改变
   final A a = new A();
       a=new A(); //引用a地址值不能被改变 //引用类型，是地址值不能被改变

qq_44725165

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
13 面对对象（代码块；继承；方法重写与方法重载的区别；final关键字）

文章目录代码块代码块的概述和分类代码块的面试题继承继承的引入和概述继承案例演示以及继承的好处和弊端Java中类的继承特点继承的注意事项和什么时候使用继承继承中成员变量的关系this和super的区别和应用继承中构造方法的关系继承中构造方法的注意事项继承中的面试题继承中成员方法关系方法重写与方法重载的区别方法重写概述及其应用方法重写的注意事项final关键字继承使用继承前的学生和老师案例使用继承后的...
复制链接

扫一扫