JAVA基础语言面向对象之---继承

最新推荐文章于 2023-04-01 10:20:31 发布

送小孩喝稠酒

最新推荐文章于 2023-04-01 10:20:31 发布

阅读量138

点赞数

本文链接：https://blog.csdn.net/qq_44823091/article/details/89342275

版权

JAVA基础语言面向对象之—继承

代码块

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

案例：各个代码块的执行顺序

public class MyDemo {
    public static void main(String[] args) {
        System.out.println("我是main方法");//执行步骤１
         Student s1 = new Student();
        Student s2 = new Student();
   }
}
    class Student {
        static {
            System.out.println("Student 静态代码块"); //２
        }

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

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

面向对象的特点：继承

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

继承已存在的类，就是复用（继承）这些类的方法和成员，在此基础上还可以在新类中添加一些新的方法和成员，以满足新的需要。这是JAVA程序设计的一项核心技术。
B:继承格式：

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

案例：普通员工和经理都是公司的职员，有许多共性，可以抽取到一个staff类中，员工和经理类便可继承staff类，但也有各自的特性，可以在各自的类中新加。

public class MyDemo2 {
    public static void main(String[] args) {
        Employee employee = new Employee();
        employee.name= "黎明";
        employee.age = 26;
        employee.salary = 15000;
        System.out.println(employee.name+"---"+employee.age+"---"+employee.salary);
        employee.sation();

        System.out.println("----------------------");

        Manager manager = new Manager();
        manager.name = "李天";
        manager.age = 35;
        manager.salary = 24000;
        System.out.println(manager.name+"---"+manager.age+"---"+manager.salary);
        manager.bonus();
    }
}

//抽取共性，staff类为父类
class Staff{
     String name;
    int age;
    double salary;
}

//子类Employee类，继承Staff父类
class Employee extends Staff{
    public void sation(){
        System.out.println("岗位是：普通员工");
    }
}

//子类Manager类，继承Staff父类
class Manager extends Staff{
    public void bonus(){
        System.out.println("经理有奖金");
    }
}

C:继承的好处：
a:提高了代码的复用性，b:提高了代码的维护性，c:让类与类之间产生了关系，是多态的前提
D:继承的弊端：
类的耦合性增强了。

开发的原则：高内聚，低耦合。耦合：类与类的关系。内聚：就是自己完成某件事情的能力。
E:Java中类的继承特点：
a:Java只支持单继承，不支持多继承。b:Java支持多层继承(继承体系)
案例演示:
Java中类的继承特点

public class MyDemo3 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println(zi.a);   //zi类继承了Fu类，Fu类继承了A类
        System.out.println(zi.b);
        System.out.println(zi.d);
        // System.out.println(zi.c);   //父类私有的成员，子类不能继承。
        //Fu fu = new Fu();
        //fu.show();    //父类私有的成员，子类不能继承。
    }
}

//Object是所有类的顶层父类，所有类都是直接，或简介继承自他
class A extends Object{
    int a=100;
    private  void show(){
        System.out.println("这是一个私有的方法");
    }
}

class Fu extends A{
    int b=200;
    private int c=10;
}

class Zi extends Fu{
    int d = 20;
}

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

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

public class MyTest {
    public static void main(String[] args) {
        B b = new B();
        int num=1;
        b.show(num);
    }
}

class A{
    int num=100;
}

class B extends A{
    int num=200;
    public void show(int num){
        //就近访问原则
        System.out.println(num);  //访问到局部变量1
        System.out.println(this.num);  //访问子类的成员变量200
        System.out.println(new A().num);  //访问父类的成员变量100   
    }
}

继承中this和super的区别和应用

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

案例演示：

public class MyTest {
    public static void main(String[] args) {
        B b = new B();
        b.show(1);
        b.hehe();
        System.out.println("------------");
        b.test();

    }
}

class A {
    int a = 200;

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

//B类继承A类
class B extends A {
    int a = 100;

    public void show(int a) {
        System.out.println(a);    //访问局部变量1
        System.out.println(this.a);    //访问本类的成员变量100
        System.out.println(super.a);   //访问父类的成员变量200
    }

    public void test2() {
        System.out.println("这是子类test2方法");
    }

    public void test() {
        this.test2();    //访问本类的方法
        this.hehe();    //本类对象调用父类的方法
        super.hehe();   //使用父类的空间标识去调用父类的方法
    }
}

继承中构造方法的关系

A:案例演示:

子类中所有的构造方法默认都会访问父类中空参数的构造方法

public class MyTest {
    public static void main(String[] args) {
        //构造方法，不参与继承。
        Son son = new Son();
        //我们在创建子类对象时，会先去执行父类的空参构造
        Son son1 = new Son(10);
    }
}

class Father{
    int num=1000;
    public Father() {
        //super();   //默认
        System.out.println("这是父类的空参构造");
    }
}

class Son extends Father{
    int b=10;
    public Son() {
        //super();   //默认
        System.out.println("这是子类的空参");
    }

    public Son(int b) {
        //super();  //默认
        this.b = b;
        System.out.println("子类有参构造执行了");
    }
}

结果为：
这是父类的空参构造
这是子类的空参
这是父类的空参构造
子类有参构造执行了

B:为什么呢?
因为有了继承关系后，那么我们在初始化子类时，先要完成父类数据的初始化，因为，我们子类要去继承父类的数据，可能还会要使用父类的数据，所以肯定先要让父类的构造方法执行，来完成对父类数据的初始化，然后在完成自己的数据的初始化。
```
其实：
	每一个构造方法的第一条语句默认都是：super()  调用父类的空参构造，先完成父类数据的初始化
	在这里简单的提一句，Object类。否则有人就会针对父类的构造方法有疑问。Object在没有父类了。
```

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

父类没有无参构造方法,子类怎么办?
a: 在父类中添加一个无参的构造方法
b:子类通过super去显示调用父类其他的带参的构造方法
c:子类通过this去调用本类的其他构造方法，本类其他构造也必须首先访问了父类构造

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

        Zi zi2 = new Zi(1009);
        System.out.println(zi.num);    
    }
}

class Fu{
    int num=10;
	
	//a: 在父类中添加一个无参的构造方法
    public Fu() {
        super();
        System.out.println("父类的空参构造执行了");
    }

    public Fu(int num) {
        super();
        this.num = num;
        System.out.println("父类的有参构造执行了");
        System.out.println(this.num);    //1009
    }
}

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

    public Zi(int num) {
        super(num);       //子类可以去调父类有参构造
        System.out.println("子类的有参构造执行了");
    }
}

继承中成员方法关系

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

方法重写及其应用

A:什么是方法重写
子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。
B: 检测是否方法重写：@Override
C:方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又扩展了父类的功能，定义了子类特有的内容。
D:方法重写注意事项：
a:父类中私有方法不能被重写，因为父类私有方法子类根本就无法继承
b:子类重写父类方法时，访问权限不能更低，最好就一致，public>protected>缺省的>private
c:父类静态方法，子类也必须通过静态方法进行重写

案例演示：

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

class Fu {
    protected void show() {
        System.out.println("喜欢打篮球");
    }
    public static void test(){
        System.out.println("父类的静态方法");
    }

}

class Zi extends Fu {

    @Override   //检测是否为方法重写
    public void show() {
        super.show();
        System.out.println("子类还喜欢羽毛球");
    }
    
    public static void test() {

    }
}

final关键字

修饰符，最终的，可以修饰类，变量，成员方法
final修饰特点：
修饰类：被修饰类不能被继承
修饰方法：被修饰的方法不能被重写
修饰变量：被修饰的变量不能被重新赋值,因为这个量其实是一个常量，，final int NUM=100;自定义常量，命名全部大写。
final修饰基本类型，是值不能被改变；修饰引用类型，是地址值不能被改变

送小孩喝稠酒

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础语言面向对象之---继承

JAVA基础语言面向对象之—继承代码块A:代码块概述在Java中，使用{}括起来的代码被称为代码块。B:代码块分类根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。C:常见代码块的应用a:局部代码块在方法中出现；限定变量生命周期，及早释放，提高内存利用率b:构造代码块在类中方法外出现；多个构造方法方法中相同的代码存放到一起...
复制链接

扫一扫