JAVA核心（封装，继承，多态）

public class Person{

    private int age;
       
    //get方法
    public int getAge(){
        return age;
    }

    //set方法
    public void setAge(int age){//参数中的age不是上面的age，this.age才是上面的age
        this.age = age；//等号右边的age是参数中的age
    }
}

二、Static

static：

static翻译为“静态”
所有static关键字修饰的都是类相关，类级别的。
所有的static修饰的，都是采用“类名”的方法来访问。
static修饰的变量：静态变量。
static修饰的方法：静态方法。

变量的分类：

变量根据声明的位置进行划分：

在方法体当中声明的变量叫做：局部变量。

在方法体外声明的变量叫做：成员变量。

class varTest{
    //以下实例，都是对象相关，访问时采用“引用”的方法访问，需要先new对象。

    //成员变量中的实例变量。
    int i;
    public viid m2(){

    } 
    //以下静态的，都是类相关的，访问时采用“类名”的方式访问，不需要new对象。
    static int k;
    public static void m1(){
    
    }
}

1、加static的变量叫做静态变量。

2、静态变量在类加载时初始化，不需要new对象。

3、静态变量存储在方法区。

静态代码块

什么是静态代码块，语法是什么？

使用static关键字可以定义：静态代码块。

static {

java语句；

java语句；

}

static静态代码块在什么时候执行？

类加载时执行，并且只执行一次。

注意：静态代码块在类加载时执行，并且在main方法执行前执行。

静态代码块一般是按照自上而下的顺序执行。

public class Test06{

    //静态代码块（特殊的时机，类加载时机。）
    
    static{
        System.out.println("A");
    
   } //一个类中可以编写多个静态代码块    
    
    static{
       System.out.println("B");
   }
    
    public static void main(String[] agrs){
    
   }
    
    static{
       System.out.println("C");
   }
    
}

三、实例语句块

实例语句块

除了静态代码块之外，还有一种语句叫做：实例语句块。

实例语句在类加载时，没有执行。

实例语句语法

{

java语句；

}

实例语句块在什么时候执行？

只要是构造方法执行，必然在构造方法执之前，自动执行“实例语句块”中的代码。

public class Test{
    public static void main(String[] agrs){
        System.out.println("main begin");
    }
   //实例语句块
    {
        System.out.println("实例语句块执行");
    }
    
    public InstanceCode(){
        System.out.println("无参数构造方法");
    }    

   
}

四、this

this什么？

this是一个关键字，全部小写。
一个对象一个this。
this是一个变量，是一个引用，this保存当前对象的内存地址，指向自身。所以，严格意义上来说，this代表的就是“当前对象”。
this存储在堆内存当中对象的内部。
this只能使用在实例方法中。谁调用这个实例方法，this就是谁（还可以在构造方法中）所以this代表的是“当前对象”。
“this”大部分情况下是可以省略的。
this不能使用在静态代码中，静态方法中不存在当前对象。

this什么时候不能省略?

class student{
    private int no;
    
    public student(){
        
    } 
    public student(int no){
        this.no = no;
    }

    public void setNo(int no){
        this.no = no;
    }
}

1、this除了可以使用在实例方法中，还可以用在构造方法中。

2、新语法：通过当前的构造方法去调用另一个本类的构造方法，可以使用以下语法格式：

this(实际参数列表);

3、this()这个语法作用是什么？

public class Date{
    private int year;
    private int month;
    private int day;


    public Date(){//构造方法无参   
        this(2020,1,1);
   }
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day  = day;
    }
}

对this()的调用只能是构造方法的第一行。

五、继承

继承作用？

基本作用：子类继承父类，代码可以得到复用

主要（重要）作用：因为有了继承关系，才有了后期的方法覆盖和多态机制。

class 类名 extends 父类名{

类体；

}

继承也是存在缺点的：耦合度高，父类修改，子类受牵连。

任何一个类，没有显示继承任何类，默认继承Object。

注意：当源码当中一个方法以“；”结尾，并且修饰符列表中有“native” 关键字，表示底层调用C++写的dll程序（dll动态链接库文件）

class A{
}

class B extends A{
}

java核心（方法的覆盖与多态）

六、覆盖

什么时候我们会考虑使用“方法覆盖”呢？

子类继承父类之后，当继承过来的方法满足当前子类的业务需求时，子类有权力对这个方法进行重载编写，有必要进行“方法的覆盖”。
方法的覆盖又叫做：方法重写，英语单词叫做： override overwrite 都可以
比较常见的：方法覆盖，方法重写，override

class Animal{
    public void move(){
        System.out.println("动物在移动");
    }
}

class Bird extends Animal{
  //对move方法进行覆盖，方法重写，override
  //最好将父类中的方法原封不动的复制过来（不建议手动）
  //方法覆盖，就是将继承过来的那个方法给覆盖掉了，继承过来的方法没了
   
    public void move(){
        System.out.println("鸟儿在飞翔")

    }

}

class Cat extends Animal{
    //方法重写
    public void move(){
        System.out.println("猫在走猫步");
    }
}

重要结论：当子类对父类继承过来的方法进行“方法覆盖”之后，子类对象调用该方法的时候，一定执行覆盖之后的方法。

当代码怎么编写的时候，在代码级别上构成了方法覆盖呢？

条件一：两个类必须要有继承关系。

条件二：重写之后的方法和之前的方法具有：

相同的返回值类型
相同的方法名
相同的形式参数列表

条件三：访问权限不能更低，可以更高。

条件四：重写之后的方法不能比之前的方法抛出更多的异常，可以更少。

还有几点注意事项：（当学习多态方法后就明白了）

方法覆盖只是针对于方法，和属性无关。
私有方法无法覆盖。
构造方法不能被继承，所以构造方法也不能被覆盖。
方法覆盖只是针对于实例方法，静态方法没有覆盖的意义。

私有方法不能被覆盖

七、多态

1、上线转型：

子类-------转型-------->父类（自动类型转换）（upsasting）

2、向下转型

父类-------转型---------->子类（强制类型转换）（downcasting）

注意：java中允许向上转型，也允许向下转型。

无论是向上转型，还是向下转型，两种类型之间必须有继承关系，没有继承关系编译器报错。

多态指的是？

父类型引用指向子类型对象。包括编译阶段和运行阶段。

编译阶段：绑定父类的方法。

运行阶段：动态绑定子类型对象的方法。

public class Test{
    public static void main(String[] args){
            
                
            //多态

            Animal a = new Cat();//向上转型
            Cat x = (cat)a //向下转型   
    
    }
}


class Animal{

}


class Cat extends Animal{

}

八、多态开发中的作用

软件开发原则有七大原则（不属于java，这个原则属于整个软件业）

其中有一条最基本的原则：ocp（开闭原则）

什么开闭原则？

对扩展开放（你可以额外添加，没问题）对修改关闭（最好很少的修改现在有程序）。
在软件扩展过程中，修改越少越好。

对于相同值类型可以修改一下吗？

对于返回值类型是基本数据类型，必须一致。
对于返回值类型是引用数据类型，重写之后返回值，类型可以变小。（但是意义不大）

懿·格雷

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVA核心（封装，继承，多态）

一个类体当中的数据，假设分装之后，对于代码的调用人员来说，不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，来保证数据的安全性。
复制链接

扫一扫