javaee 易混淆知识点之面向对象阶段 (1)

最新推荐文章于 2024-04-26 16:58:27 发布

成为架构师的成长之路

最新推荐文章于 2024-04-26 16:58:27 发布

阅读量105

点赞数

分类专栏：复习1 文章标签： java 多态类

本文链接：https://blog.csdn.net/weixin_44417406/article/details/114675945

版权

复习1 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

面向对象阶段

1.成员变量和局部变量

1.1 成员变量: 分为实例变量和类变量.

实例变量:不以static修饰
类变量:以static修饰

public class Student {
    // 1.成员变量（属性）
    public String name;
    public int age;
    }

1.2局部变量:有形参,方法局部变量,代码块局部变量

形参:方法签名中定义的变量
方法局部变量:在方法内定义
代码块局部变量:在代码块中定义


    public Student(String n){

        name=n;

    }

2.private修饰成员变量

例如

 public class Student {

    //定义属性 注意私有

    private String name;

    private int age;
    }

要采用set/get方法快捷键Alt +Insert

//1、无参构造

    public Student(){}

    //2、有参构造

    public Student(String n){

        name=n;

    }

    //3、满无参构造

    public Student(String n,int a){

        name=n;

        age=a;

    }

     public void setName(String n) {

      	name = n;

    }

    public String getName() {

      	return name;

    }

    public int getAge() {

      	return age;

    }

}

3.继承

继承的格式:

       public class Zi extends Fu{}

      继承后成员的访问特点:

          子类继承父类后,就拥有了父类的成员变量和成员方法

4.多态

4.1形成多态:

            继承\实现

            父类的引用指向子类的对象 \ 接口的引用指向实现类的对象

            方法的重写

4.2 多态时成员访问特点

成员变量

编译看左边,运行看左边
简而言之:多态的情况下,访问的是父类的成员变量

成员方法

非静态方法:编译看左边,运行看右边
简而言之:编译的时候去父类中查找方法,运行的时候去实现类中查找方法来执行

静态方法:

静态方法:编译看左边,运行看左边
简而言之:编译的时候去父类中查找方法,运行的时候去父类中查找方法来执行
//父类动物类代码

public class Fu {
    public int num =11;

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

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

//实现类猫类代码`

package com.itheima.多态1;

public class Zi extends Fu{
    public int num =12;
    public  int num2 =20;

    @Override
    public void method() {
        System.out.println("zi类的method方法");//子类继承父类，子类有一个与父类相同参数签名的方法，并且需要重新定义此方法，此为重写。
    }

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

    public static void staticMethod() {
        System.out.println("子类中的staticMethod方法"); //静态方法能继承,不能重写
    }
    public static void staticShow() {
        System.out.println("子类中的staticShow方法");
    }
}

//测试类

public class Test {
    public static void main(String[] args) {
        //多态的关系:父类引用指向实现类对象
        Fu f = new Zi();
        //成员变量访问特点
        System.out.println(f.num);//11
        //System.out.println(f.num2);//因为父类中没有num2，所以编译报错
        //成员方法访问特点
        f.method();
        //f.show();//因为父类中没有show方法，所以编译报错
        //静态方法访问特点
        f.staticMethod();
        //f.staticShow();//因为父类中没有staticShow方法，所以编译报错

    }
}

测试结果

11
zi类的method方法
父类中的staticMethod方法

5. 模板设计模式

现在需要定义新司机和老司机类，新司机和老司机都有开车功能，开车的步骤都一样，只是驾驶时的姿势有点不同
新司机:开门,点火,双手紧握方向盘,刹车,熄火
老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火

司机模板类

public abstract class Driver {
    public void go() {
        System.out.println("开门");
        System.out.println("点火");
        // 开车姿势不确定?定义为抽象方法
        ziShi();
        System.out.println("刹车");
        System.out.println("熄火");
    }

   public abstract void ziShi();
}

新司机类

public class NewDriver extends Driver {
    @Override
    public void ziShi() {
        System.out.println("新司机双手紧握方向盘");
    }
}

老司机类

public class OldDriver extends Driver {
    @Override
    public void ziShi() {
        System.out.println("老司机右手握方向盘左手抽烟...");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        NewDriver nd = new NewDriver();
        nd.go();
        System.out.println("------------------");
        OldDriver od = new OldDriver();
        od.go();
    }
}

测试结果

开门
开门
新司机双手紧握方向盘
刹车
熄火
------------------
开门
开门
老司机右手握紧方向盘,左手抽烟
刹车
熄火

模板模式的优势是，模板已经定义了通用架构，使用者只需要关心自己需要实现的功能即可！非常的强大！

6.final 代码块

表示不可变

        修饰类:被修饰的类不能被继承

        修饰方法:被修饰的方法不能被重写

        修饰变量:被修饰的变量只能赋值一次(常量)

演示final关键字的使用

A类代码

public final class A {

}

B类代码

// public class B extends A {//由于A类是最终类，所以B类不能继承
public class B{
    public final  void method(){
        System.out.println("final method");
    }
}

C类代码

public class C extends B {
    /*
    //因为父类中method被final修饰，所以子类不能重写
    public  void method(){
       System.out.println("final method");
    }
     */
    public final int NUM1 = 10;
    public final int NUM2;
    public int num3 = 0;

    public C() {
        NUM2 = 10;
    }

    public C(int i) {
        NUM2 = i;
    }
}

测试类代码

public class Test {
    public static void main(String[] args) {
        //final修饰局部变量-基本类型
        final int I = 10;
        //I=20;
        System.out.println(I);
        //final修饰局部变量-引用类型
        final C c = new C();
        c.num3 = 30;
        System.out.println(c.num3);
    }
}

测试结果

10   // final修饰的 I不会变
--------
30   // final修饰的 NUM3不会变

7. static类

修饰成员变量:

static 修饰成员变量：称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。
static 修饰成员方法：称为类方法。静态方法在声明中有static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

static 修饰代码块{}：称为静态代码块。位于类中成员位置(类中方法外)，随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
Student.java --Student.class–以二进制的形式，加载到内存中(方法区)

 		static是静态修饰符，表示静态的意思,可以修饰成员变量和成员方法以及代码块。

         格式: static 数据类型 变量名

         特点: 可以被该类的所有对象共享一份数据

         使用: 类名.变量名
         代码执行一次 要用static代码块

7.1.静态代码块的使用

定义格式

static {
	// 静态代码块
}

测试类代码

public class Test {
    static {
        System.out.println("我是一个静态代码块");
    }

    public Test() {
        System.out.println("我是一个无参构造方法");
    }

    public static void main(String[] args) {
        System.out.println("我是一个main方法");
        new Test();
        new Test();
    }
}

结果

我是一个静态代码块
我是一个main方法
我是一个无参构造方法
我是一个无参构造方法

分析静态代码块只执行一次,并且一定执行

7.2.演示开发中static的应用

开发项目中，通常需要一些“全局变量”或“全局方法”，这些全局变量和方法。可以单独定义在一个类中，并声明为static(静态)的，方便通过类名访问，这样的类被称为工具类。

java中如Math类，Random类等也都是工具类

需求：在一个工具类中，定义一个π变量和获取数组最大值方法

//工具类代码

public class Utils {
  //定义全局变量
  public static double PI = 3.14;

  //定义全局方法
  public static int getMax(int[] arr) {
    int max = arr[0];
    //输入itar快速生产普通for循环
    for (int i = 1; i < arr.length; i++) {
      if (arr[i] > max) {
        max = arr[i];
      }
    }
    return max;
  }
}

测试类代码

public class Test {
  public static void main(String[] args) {
    //  调用全局变量
    System.out.println("全局变量PI：" + Utils.PI);
    //  调用全局方法
    int[] arr = {1, 5, 8, 12, 0};
    int max = Utils.getMax(arr);
    System.out.println("最大值是：" + max);
  }
}

输出结果 3.14 和 12

8.匿名内部类

8.1概述

匿名内部类：它的本质是一个带具体实现的父类或者父接口的匿名的实现类对象。

匿名内部类的使用意义

	开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作

创建自定义类，继承父类或实现接口
重写接口或父类中的方法
创建自定义类对象
调用重写后的方法

我们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是做这样的快捷方式。

前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

8.2演示匿名内部类使用

飞行接口

public interface class FlyAble{
    public abstract void fly();
}

未完

成为架构师的成长之路

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
javaee 易混淆知识点之面向对象阶段 (1)

面向对象阶段1.成员变量和局部变量1.1 成员变量: 分为实例变量和类变量.实例变量:不以static修饰类变量:以static修饰public class Student { // 1.成员变量（属性） public String name; public int age; }1.2局部变量:有形参,方法局部变量,代码块局部变量形参:方法签名中定义的变量方法局部变量:在方法内定义代码块局部变量:在代码块中定义 public Stud
复制链接

扫一扫