JavaSE学习笔记22-7-18~24（二）

最新推荐文章于 2024-09-01 10:46:24 发布
最新推荐文章于 2024-09-01 10:46:24 发布
阅读量130 收藏
点赞数 1
分类专栏： Java学习笔记 文章标签： 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/noir250/article/details/125902570
版权
本文详细解析了封装、继承和多态三大面向对象编程特性。封装保护变量安全，通过公有方法访问；继承减少代码重复，子类继承父类属性和方法；多态允许不同类实例执行相同方法产生不同效果。还介绍了抽象类、接口、内部类和枚举等概念。
摘要由CSDN通过智能技术生成

08.三大特性

    封装、继承和多态是面向对象编程的三大特性

封装

    现有一个Student类，里面有成员变量 考试分数score，如果我们能通过new一个对象对其分数进行直接修改，那tm还能行吗？！封装的目的就是为了保证变量的安全性，使得用户只能通过外部接口（见多态）访问类的成员，而不能直接对实例变量进行查看与修改。讲的更明白些，就是把类的属性私有化，再通过公有方法进行访问和修改

public class Student{
    private String name;
    private int score;		//无法直接访问修改
    
    public Student(String name, int score){		
        this.name = name;
        this.age = age;
    }
    
    public String getName(){
        return name;
    }
    
    public int getScore(){
        return score;		//通过公有方法对私有属性进行访问
    }
}

    封装使得方法成为一个“黑箱”，只需知道其作用不用知道其实现细节，在修改属性名时，不会影响外部接口对属性的访问

//修改前
private String name;

public String getName(){
    return name;
}

//修改后
private String firstname;
private String lastname;

public String getName(){
    return firstname + lastname;	//仅改变方法的实现
}

    另外，如果用户通过公有方法访问属性时按一定的规矩办事或者得到一些提示，通过封装可以实现这些小操作。比如说你不能在更改年龄时输入250岁，这显然不可能

private String name;
private int age;

public setName(String name){
    System.out.println("请输入你的姓名：");		//提示
    this.name = name;
}

public setAge(int age) throw Exception{		
    if(age < 0 || age > 150){
        throw new Exception("年龄不符合规范");		//抛出异常，避免非法的输入
    }
    this.age = age;
}

继承

    在定义了不同类的时候可能会存在一些相同的属性和方法，为了代码复用、减少重复工作可以把这些共同属性抽象成一个父类。比如说，Student和Worker都拥有姓名、年龄等属性和吃饭、睡觉等方法，为了减少代码的重复定义，可以把这些抽象成一个Person类，因为人都是有姓名年龄、能够吃饭睡觉的，这些都是人的共性。此时就可以把Student和Worker称作子类，Person称作父类。再比如Cat、Dog、Pig和Animal的关系。子类可以复用父类非私有的方法和属性，且可在此基础上新增方法和属性

    每一个子类必须定义一个实现父类构造方法的构造方法，即在构造方法开始使用super关键字，如果父类使用的是默认构造方法，那么子类就不用手动声明

//文件：Person.java
public class Person {	

    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
}
//文件：Student
public class Student extends Person{	//通过extends关键字来继承父类

    public Student(String name, int age){	//实现父类构造方法的构造方法
        super(name,age);	//通过super关键字(指代父类)实现父类的构造方法
    }

    public void learn(){
        System.out.println("我好喜欢学习啊！");		//子类特有的方法
    }
}
//文件：Worker
public class Worker extends Person{

    public Worker(String name, int age) {
        super(name, age);
    }

    public void work(){
        System.out.println("劳动最光荣！");
    }
}

    需要注意的是，Java是单继承语言，每个子类都只有一个父类；如果一个类没有继承任何类，那么这个类默认继承Object类。当然，即使继承自某个类，但最顶层的父类仍然是继承自Object类的。

多态

    从字面意思讲，多态就是多种形态，在Java中指一个类有多种表现形态，即一个方法由于实现类的不同而导致执行的结果也不同

方法的重写

    方法的重写与重载不一样，重写指对原有方法的覆盖。子类可以提升父类方法的访问权限，但private修饰的方法和静态方法不能被重写

//文件：Person.java
public class Person{
    public void eat(){
        System.out.println("我吃饭了");
    }
}

//文件：Student.java
public class Student extends Person{
    @Override		//声明这个方法是重写的，不过可以省略，但是不建议
    public void eat(){
        System.out.println("真香");
    }
    
    public void learn(){
        System.out.println("学习真好玩");
    }
}

    如果在重写方法时，不仅想使用子类自己的逻辑，也想直接调用父类的方法或变量，可以用super关键字访问

public void eat(){
    super.eat();	//调用父类的方法
    System.out.println("真香");	//子类的逻辑
}	//输出为：我吃饭了 真香

类型转换

    存在亲缘关系的类之间也可以进行类型转换，可以分为向上转换和向下转换两种。当向上转型之后，父类引用变量可以访问子类中属于父类的属性和方法，但是不能访问子类独有的属性和方法。只有当对象原本就是通过向上转型得到的时候，才能进行向下转型

//向上转型
Person person = new Student("阿伟",20);	//父类变量引用子类实例
person.eat();	//得到具体实现（Student）的结果，而不是当前类型（Person）的结果 输出为：真香
person.learn();		//报错，因为learn方法是子类特有的方法。

//向下转型
Person person = new Student("阿伟",20);	//通过子类向上转型创建的对象
Student student = (Student)person;		//将原本的Person类向下转型成具体的子类Student
student.eat();		//调用具体实现类的方法

instanceof关键字

    instanceof是Java的一个保留关键字，返回值类型是布尔值Booleam，格式为 对象 instanceof 类，能够判断左边的对象是不是右边类或其子类的具体实现

//现有一个Person类型的实例person，要判断其是Student类还是Worker类的实现（假设Person类仅有这两个子类）
private static void test(Person person){
    if(person instanceof Student){
        Student student = (Student)person;
        student.learn();
    }
    else if(person instanceof Worker){
        Worker worker = (Worker)person;
        worker.work();
    }
}

final关键字

    final一共有四个用法

  • 修饰类：这个类不能有子类（太监类），类中所有的成员方法不能被重写。
  • 修饰成员方法：该方法为最终方法，不能被重写。
  • 修饰局部变量：对于基本类型来说，该变量中的数据不能改变；对于引用类型来说，该变量中的地址值不能改变。
  • 修饰成员变量：由于成员变量具有默认值，所以用final后必须手动赋值；对于final的成员变量，要么直接赋值，要么用构造方法赋 值，只能2选1；必须保证类中所有重载的构造方法都会最终对final的成员变量进行赋值。
private final String name;
private final int age;

public Student(String name, int age){
    this.name = name;
    this.age = age;		//通过构造方法对final修饰的成员变量进行初始化
}

抽象类

    抽象类从字面意思上讲就是比类更抽象的类，在普通类中增加抽象方法就成了抽象类，需要用abstract关键字去声明。抽象方法是没有方法体的方法，不能被对象直接使用，同样用abstract关键字去修饰

public abstract Person{		//定义一个抽象类    
    public abstract void eat();		//无方法体，为抽象方法    
    public void talk(){
        System.out.println("说话");		//有方法体，为普通方法
    }
}

    抽象类可以保留特征，但不保留具体呈现形态，方法由非抽象的子类去实现，子类必须对所继承抽象类中所有的抽象方法进行重写，且创建实例时需使用向上转型处理。另外，抽象类是单继承的，子类只能继承一个父类

public abstract Person{    
    public abstract void eat();    //定义一个抽象方法
}

class Student extends Person{
    @Override
    public void eat(){
        System.out.println("我在吃饭");		//子类对父类抽象方法的重写
    }
}

public class Test{
    public static void main(String[] args){
        Person person = new Student();		//向上转型
        person.eat();		//通过子类实现 输出为：我在吃饭
    }
}

接口

    接口包含了一系列方法的定义，只有方法的特征而没有其实现，需要类去实现。接口可以理解成代表某个确切功能，比抽象类更加抽象。举个例子，人和狗都有吃的行为（此处应把人与狗的吃理解成不同的行为，比如人吃饭而狗吃狗粮），甚至对于手机也能把充电理解成吃,那么就可以把吃作为一个接口，通过方法的重写分别在人、狗、手机上具体实现

//文件：Eat.java
public interface Eat{		//通过interface关键字声明一个接口
    void eat();
}	

//文件：Person.java
public class Person implements Eat{		//通过implements关键字声明实现的接口
    @Override
    public void eat(){
        System.out.println("我是人，我在吃饭");		//对接口中方法的重写
    }
}

//文件：Dog.java
public class Dog implements Eat, ...{	//接口能够实现多继承的功能即每个类可以实现多个接口，每个接口之间用‘,’分开
    @Override
    public void eat(){
        System.out.println("我是狗，我在吃狗粮");
    }
}

//文件：Phone.java
public class Phone implements Eat{
    @Override
    public void eat(){
        System.out.println("我是手机，我在充电");
    }
}

//文件：Test.java
public class Test{
    public static void main(String[] args){
        Person person = new Person();
        Dog dog = new Dog();
        Phone phone = new Phone();
        person.eat();
        dog.eat();
        phone.eat();
    }
}
//输出：我是人，我在吃饭 我是狗，我在吃狗粮 我是手机，我在充电

    接口中的变量默认为 public static final ；另外，一个类可以实现多接口并不是指多继承；实现接口的类能通过Instanceof关键字判断，支持向上和向下转型。

09.内部类

    定义在类内部的类叫作内部类，可分为四种：成员内部类、静态内部类、局部内部类和匿名内部类。

成员内部类

    类中直接嵌套的类是成员内部类，是属于对象的，因此要创建内部类的对象，必须要先创建外部类的对象

public class Test{
    
    class Inner{

    }
    
    public static void main(String[] args){
    	Test test = new Test();		//先创建外部对象
    	Inner inner = test.new Inner();		//通过外部对象创建内部对象
	}
}

静态内部类

    静态内部类是属于类的，因此不需要像上面这么麻烦，可以直接通过类名.访问，省去了创建对象的过程

public class Test{
	
    static class Inner{

    }
    
    public static void main(String[] args){
    	Test.Inner inner = new Test.Inner();	//通过类名.直接访问
	}
}

局部内部类

public class Test{
    public void test(){
    	class Inner{
        
    	}
    	Inner inner = new Inner();
    }
}

匿名内部类

    如果一个接口/类的方法在程序中只需执行一次，为此创建其实现类或子类并重写方法是非常不值的，此时可以用匿名内部类在new的时候直接写对应的实现，减少冗余代码。缺点也很明显，仅限在这里使用，不能够代码复用。另外，可以借助 lambda表达式实现简化

public static void main(String[] args){
    Eat eat = new Eat(){
        @Override
        public void eat(){
            //重写的方法
        }
    };		//此处‘;’不能忘记！本质是Eat eat = new Eat();
}

//lambda表达式简化格式：
public static void main(String[] args){
    Eat eat = () -> {};
}

10.枚举类

    枚举类是指对象有限且固定的类，默认继承Enum类，可以使用Enum类的方法，通过关键字enum定义。举个例子，某个程序需要你传入今天是星期几，照理来说你得按照他的要求输入MON、TUE、…，但也不排除有一些大聪明非得输入个 “星期2” ，这样就显得不严谨了。因为星期几是固定的7个，所以需要枚举类。

public enum WeekdayEnum{	//通过enum关键字声明
    SUN,MON,TUE,WED,THU,FRI,SAT;
}

    非抽象枚举类默认由final修饰，不能被继承；枚举类的构造方法默认由private修饰，若使用其他则会报错；所有实例必须在第一行全部列出，代表该枚举类所有可能出现的实例，默认由public static final修饰。
    通常会使用构造方法来进行初始化，而在第一行我们列举出所有的实例时，其实就已经调用了构造方法；一旦默认的无参构造被我们人为定义的有参构造覆盖的话，我们在列举实例时就必须带上对应的参数

//文件：StatusEnum.java
public enum StatusEnum{		//声明一个状态的枚举类
    STUDYING("学习"),EATING("吃饭"),WORKING("工作");		//此时就已经调用了有参构造方法
	
    private final String name;		//成员变量：状态名
    private StatusEnum(String name){
        this.name = name;		//有参构造，初始化
    }
    public String getName(){		//成员方法：获取状态，返回状态名
        return this.name;
    }
}
//文件：Student.java
public class Student{
    private String name;
    private int age;
    private StatusEnum status;
    
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    
    public void setStatus(StatusEnum status){
        this.status = status;
    }
    public StatusEnum getStatus(){
        return status;
    }
}
//文件：Test.java
public class Test{
    public static void main(String[] args){
        Student student = new Student("小明",18);
        student.setStatus(StatusEnum.STUDYING);
        System.out.println(student.getStatus().getName());
    }
}
//输出为：学习

11.基本类型包装类

    Java中的基本数据类型（int、double、char…）都不是类，如果想通过对象的形式去使用他们，则需要使用基本类型的包装类。包装类命名大部分是由基本类型的首字母变为大写得来的，如Byte -> byte,Boolean -> boolean,Integer ->int,Character -> char,Long -> long,Float -> float,Double -> double；包装类实际上就是把基本数据类型封装成一个类

private final int value;	//Integer内部实际还是存的一个int类型的数据

public Integer(int value){
    this.value = value;
}

public static void main(String[] args){
    Integer i = 1;	//接收参数1，通过构造方法将基本int类型的1变为Integer类型的1
}

    此处应该有个自动装箱与拆箱的内容，但我自认为目前能力不足以讲清楚，所以摆烂了。

后记

    这期算是比较重要的，因为涉及到面向对象的三大特性，对于初学者来说理解起来有点难度，所以这次我拖得时间有点长（绝对不是因为摆烂），但还是没能细致入微地去介绍，比如Enum类的各种方法。以后可能会出Enum类、ArrayList类等的源码逐行分析，我是说可能，总之有可能。

Sadio_Chin
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Person p=new student()是什么意思
qq_50777680的博客
03-02 1018
Person p=new student()是什么意思？ 定义一个父类类型的引用指向一个子类的对象
JAVA多态
qq_42216575的博客
02-24 227
多态 引用变量的声明类型可能与其实际类型不符 Person p = new Student(); 现在，我们考虑一种情况，如果子类覆写了父类的方法： public class Main { public static void main(String[] args) { Person p = new Student(); p.run(); // 应该打印Person.run还是Student.run? } } class Person { publ
Java基础语法（五）
weixin_42522705的博客
01-06 552
Java基础语法（五）面向对象定义 面向对象定义 什么是面向对象： 面向对象的本质：
Person p = new Student()； p指代谁的对象
qq_54154945的博客
01-24 1032
外部可以调用类来创建对象，比如在Test类中: Human aPerson = new Human(160); 创建了一个Human类的对象aPerson。 上面是一个非常简单的表述，但我们有许多细节需要深入: 首先看等号的右侧。new是在内存中为对象开辟空间。具体来说，new是在内存的堆(heap)上为对象开辟空间。这一空间中，保存有对象的数据和方法。 再看等号的左侧。aPerson指代一个Human对象，被称为对象引用(reference)。实际上，**aPerson并不是对象本身，而是类似于一个指向
多态Person p=new Student();
好学而不勤问非真好学者
12-17 2444
如果有两个类，一个类是Person类是父类，然后有一个类是子类Student类。 Person p=new Student(); 那么请问上面的这句话，在干什么？ 这很明显是一个里氏转换，对吧。但是为什么要用里氏转换，你明明可以写成下面这个东西用。想用谁的方法就实例化谁 Person p =new Person(); Student S =new Student(); 回到第一句话上...
JavaSE学习笔记 2023-12-25 --网络编程
CHiN_951的博客
12-27 868
网络基本知识与TCP案例
JavaSE学习笔记 2024-1-5 --WEB基础
CHiN_951的博客
01-11 417
前端开发的三层
JavaSE学习笔记之-----集合
彦帅的博客
07-30 716
JavaSE学习笔记之-----集合
JavaSE学习笔记之-----异常处理
彦帅的博客
07-23 549
JavaSE学习笔记之异常处理
JavaSE学习笔记之-----数组
彦帅的博客
07-24 522
JavaSE学习笔记之-----数组
MySQL基础学习
eugene03的博客
08-29 2164
事务是一组操作的集合，它是一个不可分割的工作单位，事务会把所有操作作为一个整体一起向系统提交或者撤掉操作请求，那么这些操作要么同时成功，要么同时失败。笛卡尔积：两个集合 A集合和B集合的所有组合情况（在多表查询时，需要消除无效的笛卡尔积）对于union 查询，就是把多次查询的结果合并起来，行程一个新的查询结果集。相当于查询表1（左表）的所有数据包含表1和表2交集部分的数据。相当于查询表2（右表）的所有数据包含表1和表2交集部分的数据。自连接查询，可以是内连接查询，也可以是外连接查询。
AI实践与学习8-AI Agent Workflow助力解题和验证答案置信度
xiaosi的博客
08-30 612
之前在试着提高解题正确率，目标100%，发现外部知识不足仅依靠大模型的话比较困难。而试题人工生产成本巨大。本质因为大模型生成内容会有幻觉特点，也就是说解答的试题正确性不太好评判，直接解答试题生产场景不太可控。后面考虑调用OpenAI解题的时候，像xxx那样通过输出置信度来帮助判断答案的正确性 or 其他形式只要能保证LLM生成答案是可靠（程序判断）的。
网络编程学习：TCP/IP协议
最新发布
kkbbaaii的博客
09-01 1051
网络编程学习：TCP/IP协议
ArkTS基础快速入门学习
weixin_49898946的博客
08-29 1305
ArkTS语言在TS语言基础上扩展了声明式UI，组件化，状态管理等功能。官方推荐两种开发模式开发鸿蒙，一种是基于js扩展的类web范式，另一种是基于TS扩展的声明式UI范式（也就是使用ArkTS开发）。主要介绍harmonyos的页面布局和组件的基础使用
html+css+js网页设计 个人博客模版 我的学习经历7个页面
qq_42431718的博客
08-28 1257
html+css+js网页设计 个人博客模版 我的学习经历7个页面 网页作品代码简单，可使用任意HTML编辑软件（如：Dreamweaver、HBuilder、Vscode 、Sublime 、Webstorm、Text 、Notepad++ 等任意html编辑软件进行运行及修改编辑等操作）。
2024.8.30 学习记录
sdhdhdhdh的博客
08-30 159
思维导图：
Kali学习（ms17-010、ms08-067漏洞复现）
2401_82985722的博客
08-28 1175
因为虚拟机有虚拟网卡，就像在windows系统里玩kali一样，他们的物理层公用一个设备-公用主机硬件，但在应用层上他们是相对独立的-互不干扰，可以同时使用。，通过一个公共的网关访问Internet，就像家里的路由器一样，多台设备连接上网，使用的是同一个外网IP。如果端口开放，就会进行完整的三次握手，成功建立链接，扫描结果中，STATE字段显示为 open。桥接就相当于，将创建的虚拟网卡，变成交换机，与主机的网卡连接，使kali可以上网。
嵌入式Linux学习笔记-Linux基础操作
汘荨的博客
08-30 881
vi 编辑器是一个运行在终端的文本编辑器，类似于 windows 下的记事本。它的升级版 vim 编辑器功能更丰富。vi 的基本操作是：从终端输入 vi 1.txt 后可进入一般模式；按 i 可进入编辑模式，按ESC退出编辑模式；输入“：”进入命令行模式执行各种命令，按ESC退出命令行模式；按“ :wq ” 保存修改并退出 vi。
集成电路学习：什么是EEPROM电可擦除可编程只读存储器
limengshi138392的博客
09-01 393
集成电路学习：什么是EEPROM电可擦除可编程只读存储器
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值