JavaSE(二)

最新推荐文章于 2024-07-22 22:58:19 发布
最新推荐文章于 2024-07-22 22:58:19 发布
阅读量170 收藏
点赞数
分类专栏： # SE 文章标签： java 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44780625/article/details/108608673
版权

文章目录

1、封装

我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度.

1.1 private实现封装

private/ public 这两个关键字表示 “访问权限控制” .

  • 被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
  • 被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.

1.2 getter和setter方法

当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了.

此时我们就需要把这些private字段封装到public的方法中，这样就更好的保护了数据。

2、继承

我们写一个类，就是为了抽象现实中的一些事物，这些事物之间是可能存在联系的，在表示成类和对象的时候也会存在一定的关联。

例如设计一个类表示动物：

public class Animal {
	public String name;
	public Animal(String name) {
		this.name = name;
	}
	public void eat(String food) {
		System.out.println(this.name + "正在吃" + food);
	}
}


class Cat {
	public String name;
	public Cat(String name) {
		this.name = name;
	}
	public void eat(String food) {
		System.out.println(this.name + "正在吃" + food);
	}
}


class Bird {
	public String name;
	public Bird(String name) {
		this.name = name;
	}
	public void eat(String food) {
		System.out.println(this.name + "正在吃" + food);
	}
	public void fly() {
		System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
	}
}

我们发现 Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系:

  • 这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
  • 这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.
  • 从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义).

此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果.

此时, Animal 这样被继承的类, 我们称为 父类 , 基类 或 超类；对于像 Cat 和 Bird 这样的类, 我们称为 子类, 派生类；子类继承父类的字段和方法, 以达到代码重用的效果.

对于上面的代码, 可以使用继承进行改进. 此时我们让 Cat 和 Bird 继承自 Animal 类, 那么 Cat 在定义的时候就不必再写 name 字段和 eat 方法.

class Animal {
	public String name;
	public Animal(String name) {
		this.name = name;
	}
	public void eat(String food) {
		System.out.println(this.name + "正在吃" + food);
	}
}

class Cat extends Animal {
	public Cat(String name) {
		// 使用 super 调用父类的构造方法.
		super(name);
	}
}

class Bird extends Animal {
	public Bird(String name) {
		super(name);
	}
	
	public void fly() {
		System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
	}
}


public class Test {
	public static void main(String[] args) {
		Cat cat = new Cat("小黑");
		cat.eat("猫粮");
		Bird bird = new Bird("圆圆");
		bird.fly();
	}
}

extends 英文原意指 “扩展”. 而我们所写的类的继承, 也可以理解成基于父类进行代码上的 “扩展”.

例如我们写的 Bird 类, 就是在 Animal 的基础上扩展出了 fly 方法.

访问权限符：
在这里插入图片描述

3、多态

多态： 一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在程序运行期间才能决定。因为在程序运行时才确定具体的类，不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

3.1 向上转型

在刚才的例子中, 我们写了形如下面的代码

Bird bird = new Bird("圆圆");

这个代码也可以写成这个样子

Bird bird = new Bird("圆圆");
Animal bird2 = bird;
// 或者写成下面的方式
Animal bird2 = new Bird("圆圆");

此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为 向上转型.

适用场景： 当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

3.2 向下转型

向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象.

Animal animal = new Bird("圆圆");
Bird bird = (Bird)animal;
bird.fly();

这就叫向下转型，将父类对象转成子类对象。

适用场景： 当要使用子类特有功能时。

3.3 动态绑定

当子类和父类中出现同名方法的时候, 再去调用会出现什么情况呢?

对前面的代码稍加修改, 给 Bird 类也加上同名的 eat 方法, 并且在两个 eat 中分别加上不同的日志.

public class Animal {
	protected String name;
	public Animal(String name) {
		this.name = name;
	}
	public void eat(String food) {
		System.out.println("我是一只小动物");
		System.out.println(this.name + "正在吃" + food);
	}
}

public class Bird extends Animal {
	public Bird(String name) {
		super(name);
	}
	public void eat(String food) {
		System.out.println("我是一只小鸟");
		System.out.println(this.name + "正在吃" + food);
	}
}

public class Test {
	public static void main(String[] args) {
		Animal animal1 = new Animal("圆圆");
		animal1.eat("谷子");
		Animal animal2 = new Bird("扁扁");
		animal2.eat("谷子");
	}
}

// 执行结果
我是一只小动物
圆圆正在吃谷子
我是一只小鸟
扁扁正在吃谷子

此时, 我们发现:

  • animal1 和 animal2 虽然都是 Animal 类型的引用, 但是animal1 指向 Animal 类型的实例, animal2 指向Bird 类型的实例.
  • 针对 animal1 和 animal2 分别调用 eat 方法, 发现 animal1.eat() 实际调用了父类的方法, 而animal2.eat() 实际调用了子类的方法.

因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定.

3.4 多态存在的三个必要条件

  • 继承
  • 重写
  • 父类引用指向子类对象

3.5 多态的实现方式

  • 重写
  • 接口
  • 抽象类

4、泛型

泛型就是指在类定义的时候不会设置类中属性或者方法中的具体类型，而是类在使用的时候再进行定义。

类型擦除机制： 泛型信息只存在于代码编译阶段，在进⼊入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。

5、反射

5.1 认识反射机制

反射指的是对象的反向处理理操作，既然是反向处理理。我们先来观察一下"正"的操作。在默认情况下，必须要先导入一个包，而后才能产生类的实例化对象。

例子：正常处理

import java.util.Date;
public class Test {
	public static void main(String[] args) {
		Date date = new Date() ;
	}
}

以上是我们正常的关于对象的处理理流程:根据包名.类名找到类

所谓的"反"指的是根据对象来取得对象的来源信息，而这个"反"的操作核心的处理理就在于Object类的一个方法:

取得Class对象:

public final native Class<?> getClass();

该方法返回的是一个Class类对象，这个Class描述的就是类。

例子：调用getClass()方法

import java.util.Date;
public class Test {
	public static void main(String[] args) {
		Date date = new Date() ;
		System.out.println(date.getClass());
	}
}

此时通过对象取得了了对象的来源，这就是"反"的本质。

在反射的世界里面，看重的不不再是一个对象，而是对象身后的组成(类、构造、普通、成员等)

5.2 3种实例化对象

Class类是描述整个类的概念，也是整个反射的操作源头，在使用Class类的时候需要关注的依然是这个类的对象。而这个类的对象的产生模式一共有三种：

  1. 任何类的实例化对象可以通过Object类中的getClass()方法取得Class类对象。
  2. “类.class”:直接根据某个具体的类来取得Class类的实例化对象。
  3. 使⽤用Class类提供的方法:public static Class<?> forName(String className) throws
    ClassNotFoundException
import java.util.Date;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        Date date = new Date();
        Class<?> cla2 = date.getClass();
        System.out.println(cla2.getName());

        Class<?> cla = Class.forName("java.util.Date");
        System.out.println(cla.getName());

        Class<?> cla1 = java.util.Date.class;
        System.out.println(cla1.getName());
        
    }
}

在以上给出的三个方法中我们可以发现，除了第一种方法会产生Date类的实例化对象之外，其他的两种都不会产生Date类的实例例化对象。于是取得了Class类对象有一个最直接的好处:可通过反射实例化对象，在Class类中定义有如下方法:

public T newInstance() throws InstantiationException, IllegalAccessException

反射实例化对象：


public class Main {
    public static void main(String[] args) throws ClassNotFoundException, 
            IllegalAccessException, InstantiationException {
        Class<?> cla = Class.forName("java.util.Date");

        //实例化对象   等价于   new java.util.Date();
        Object obj = cla.newInstance();
        System.out.println(obj);
    }
}

现在发现除了关键字new之外，对于对象的实例化模式有了第二种做法，通过反射进行。

5.3 反射VS工厂模式

工厂设计模式曾经给过原则：如果是自己编写的接口，要想取得本接口的实例例化对象，最好使用工厂类来设计。但是也需要知道传统工厂设计所带来的问题。

传统工厂类：

public interface Fruit {
    public void get();
}

public class Apple implements Fruit{
    @Override
    public void get() {
        System.out.println("Apple");
    }
}

public class Banana implements Fruit {
    @Override
    public void get() {
        System.out.println("Banana");
    }
}

public class FruitFactory {
    public static Fruit getInstance(String type) {
        if ("apple".equals(type)) {
            return new Apple();
        } else if ("banana".equals(type)) {
            return new Banana();
        } else {
            return null;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Fruit fruit = FruitFactory.getInstance("apple");
        fruit.get();
    }
}

(问题就在于new)。每增加一个接口的子类就需要修改工厂类。

传统工厂类增加接口子类：

public class Orange implements Fruit {
    @Override
    public void get() {
        System.out.println("Orange");
    }
}

public class FruitFactory {
    public static Fruit getInstance(String type) {
        if ("apple".equals(type)) {
            return new Apple();
        } else if ("banana".equals(type)) {
            return new Banana();
        } else if ("orange".equals(type)) {
            return new Orange();
        } else {
            return null;
        }
    }
}

如果要想解决关键字new带来的问题，最好的做法就是通过反射来完成处理，因为Class类可以使用newInstance()实例化对象，同时Class.forName()能够接收类名称。

修改程序：

public interface Fruit {
    public void get();
}

public class Apple implements Fruit{
    @Override
    public void get() {
        System.out.println("Apple");
    }
}

public class Banana implements Fruit {
    @Override
    public void get() {
        System.out.println("Banana");
    }
}

public class Orange implements Fruit {
    @Override
    public void get() {
        System.out.println("Orange");
    }
}

public class FruitFactory {
    public static Fruit getInstance(String className) {
        Fruit fruit = null;
        try {
            fruit = (Fruit) Class.forName(className).newInstance();
        } catch (InstantiationException | IllegalAccessException
                | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return fruit;
    }
}

public class Main {
    public static void main(String[] args) {
        Fruit fruit = FruitFactory.getInstance("orange");
        fruit.get();
    }
}

引入反射后，每当新增接口子类，无需去修改工厂类代码就可以很方便的进行接口子类扩容。以上这种工厂类代码我们称之为简单工厂模式

5.4 ClassLoader类加载器

Class类描述的是整个类的信息，在Class类中提供的forName()方法,这个方法根据ClassPath配置的路径进行类的加载，如果说现在你的类的加载路路径可能是网络、文件，这个时候就必须实现类加载器，也就是ClassLoader类的主要作用。

5.4.1 认识ClassLoader

例子：

// ⾃自定义类，这个类⼀一定在CLASSPATH中
class Member{}
public class TestDemo {
	public static void main(String[] args) {
		Class<?> cls = Member.class ;
		System.out.println(cls.getClassLoader()) ;
		System.out.println(cls.getClassLoader().getParent()) ;
		System.out.println(cls.getClassLoader().getParent().getParent());
	}
}



//运行结果：
//sun.misc.Launcher$AppClassLoader@58644d46
//sun.misc.Launcher$ExtClassLoader@6a38e57f
//null

此时出现了两个类加载器:ExtClassLoader(扩展类加载器)、AppClassLoader(应用程序类加载器)。

类加载过程？

  1. 加载：根据查找路径找到相应的class文件，然后导入。类的加载方式分为隐式加载和显示加载两种。
  • 隐式加载指的是程序在使用new关键词创建对象时，会隐式的调用类的加载器把对应的类加载到jvm中。
  • 显示加载指的是通过直接调用class.forName()方法来把所需的类加载到jvm中。

  1. 检查：检查夹加载的class文件的正确性。

  2. 准备；给类中的静态变量分配内存空间。

  3. 解析：虚拟机将常量池中的符号引用替换成直接引用的过程。符号引用就理解为一个标示，而在直接引用直接指向内存中的地址。

  4. 初始化：对静态变量和静态代码块执行初始化工作。

什么是类加载器？

负责动态加载Java类到Java虚拟机的内存空间中。

Bootstrap(启动类加载器)： 是虚拟机自身的一部分，其他类加载器都独立于JVM外部，并且都继承于启动类加载器。负责把<Java_HOME>\lib目录下核心类库的jar包加载到内存中

ExtClassLoader(扩展类加载器)： 它负责将<Java_HOME>\lib\ext目录下的jar包加载到内存中。

AppClassLoader(应用程序类加载器): 负责加载用户类路径(ClassPath)上指定的类库到内存。

5.4.2 双亲委派模型

在这里插入图片描述
上图展示的类加载器之间的这种层次关系，就称为类加载器的双亲委派模型。

双亲委派模型的工作流程是：如果一个类加载器收到了类加载请求，它首先不会自己去尝试加载这个类，而是把这个请求委托给父类加载器去完成，每一个层次的类加载器都是如此。因此，所有的加载请求都应当传送到顶层的BootStrap加载器中，只有当父加载器器反馈无法完成这个加载请求时(在自己搜索范围中没有找到此类)，子加载器器才会尝试自己去加载。

:-D:）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
JavaSE部分复习（二）
萧寒的博客
11-19 139
JavaSE基础部分复习（二）前言二、JavaSE面向对象1.类2.this关键字3.构造方法4.Static 静态关键字5.代码块:6.继承（extends）7.抽象类 前言 这一部分复习一下面向对象的相关知识，设计面向对象的基础知识，继承，接口，抽象类等。 二、JavaSE面向对象 1.类 类的格式： 标准类的代码写法和测试 类 ● ——成员变量（public、private） ● ——构造方法 无参构造方法 （建议自己加一个） 带参构造方法（各种重载） ● ——成员方法 getXxx()（返回类
JavaSE目录
热门推荐
本人主攻Java，希望自己能成为出色的程序员。
02-04 35万+
跳转到总目录 01、版本一：视频教程笔记 这个版本是我跟着视频教程做的笔记 教程来源：java基础到高级_零基础自学Java–尚硅谷–宋红康 教程视频地址：https://www.bilibili.com/video/BV1ny4y1Y7CW 名称 笔记地址 一：Java语言概述 二：变量、标识符、保留字、变量 三：运算符 四：程序流程控制 五：数组 六：面向对象（上） 七：面向对象（下） 八：面向对象（中） 九：异常 十：多线程
Javase二维数组的遍历
ssizj的博客
01-28 653
利用增强for循环进行遍历 public class Demo05 { //二维数组 public static void main(String[] args) { int[][] arrays = {{1,1,1,1},{45,8,9,7},{},{4,5,4,5},{4,9,8}}; printArrays(arrays); } public static void printArrays(int[][] arrays){
JavaSE（总结）
hbx_Ambition的博客
03-23 572
第一部分： 基础知识 第二部分： 面向对象 封装 类：对一类事物抽象所得到的概念 对象：一个具体的事物 构造函数： 不能有返回值 方法名与类名相同 可以有多个 默认生成无参方法体无返回值的构造函数 自己一旦定义，编译器将不再生成默认的构造函数 生成一个类对象时，能且只能调用其中的一个构造函数 static：静态的
JavaSE第二阶段.xmind
08-26
JavaSE进阶学习图
javaSE.docx
09-11
Java支持十进制、二进制、八进制和十六进制的表示，并提供了转换方法。 总的来说，Java SE提供了丰富的功能和工具，使得开发者能够构建高效、可靠的软件系统。理解并掌握Java的基础知识，对于任何想要进入IT行业的...
JavaSE.docx
08-09
JavaSE是Java Standard Edition的缩写，它是Java平台的核心部分，主要用来开发和部署桌面应用。在这个文档中，我们关注的是JavaSE中的方法定义、数组操作以及控制流语句。 首先，我们来看方法的定义。在Java中，...
javase总结
05-08
这份"javase总结"涵盖了Java语言的基础和核心概念，对于懒人学者来说，它提供了一条清晰的学习路径，无需在海量资料中寻找关键信息。以下是根据标题、描述和文件名提炼出的Java SE相关知识点： 一、Java基础 1. **...
javase笔记.7z
05-24
二、内存管理与垃圾回收 1. **内存区域**：Java程序运行时，会分为堆内存、栈内存、方法区、本地方法栈等区域。其中，对象在堆内存中分配，局部变量在栈内存中分配。 2. **垃圾回收**：Java的自动内存管理机制，...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 738
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 692
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 711
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1237
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1265
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1123
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1099
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
最新发布
Aishangyuwen的博客
07-22 829
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 925
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
JavaSE构造方法重载实践解析
2. 第二个构造方法 `MyTime(int mHour)` 接收一个整数参数，代表小时，分钟和秒都设置为0。 3. 第三个构造方法 `MyTime(int hour, int minute)` 接收小时和分钟参数，秒被初始化为0。 4. 第四个构造方法 `MyTime(int...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值