我的学习笔记

最新推荐文章于 2024-07-22 14:10:07 发布
最新推荐文章于 2024-07-22 14:10:07 发布
阅读量1k 收藏 27
点赞数 23
文章标签： 学习 笔记 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80070214/article/details/135893981
版权
本文介绍了JavaScript的基础学习，包括异步编程和如何创建动态列表，以及Java面向对象编程的关键概念如封装、继承、多态、抽象类和接口，以及异常处理的实践应用。
摘要由CSDN通过智能技术生成

js的学习

上周学到了js的异步编程，这周对js的学习进行的基本首位，掌握了js基本用法，可以制作一些简单的网页。

<!DOCTYPE html>
<html>
<head>
    <title>JS动态列表</title>
    <style>
        .list {
            font-family: Arial, sans-serif;
            margin: 20px;
            padding: 20px;
            border: 1px solid #ddd;
        }
        .list-item {
            margin-bottom: 10px;
        }
    </style>
    <script src="main.js"></script>
</head>
<body>
    <div id="listContainer">
        <button onclick="addItem()">添加项</button>
        <div id="list" class="list">
        </div>
    </div>
</body>
</html>
var list = document.getElementById("list");

function addItem() {
  var listItem = document.createElement("div");
  listItem.className = "list-item";
  listItem.textContent = "列表项 " + (list.children.length + 1);

  list.appendChild(listItem);
}

Java面向对象的学习

上一次学习我们讲述了很多理论知识，这一次我们就用代码实例来对接下来的问题进行讲解。

1.Java面向对象的三大特性：封装，继承和多态

首先让我们看看面向对象的封装，也就是只暴露必要的接口，为了方便理解我们用代码来掩饰：

public class Person {
    
    // 私有属性
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 公开的getter和setter方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    // 公开的方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
    
    // 入口方法
    public static void main(String[] args) {
        // 创建一个Person对象
        Person p = new Person("John", 25);
        
        // 调用公开的方法
        p.sayHello();
        
        // 调用setter方法修改属性值
        p.setName("Tom");
        p.setAge(30);
        
        // 再次调用公开的方法
        p.sayHello();
    }
}

这个示例中，创建了一个Person类，该类有一个私有属性name和age，以及相应的getter和setter方法用于访问和修改属性值。还有一个公开的sayHello方法用于打印个人信息。在主方法中，创建了一个Person对象并调用了一系列方法来操作对象的属性和行为。

接下来我们在看看面向对象的继承代码实例：

// 创建一个父类Animal
public class Animal {
    // 公开的方法
    public void eat() {
        System.out.println("Animal is eating...");
    }
    
    public void sleep() {
        System.out.println("Animal is sleeping...");
    }
}

// 创建一个子类Dog，继承自Animal
public class Dog extends Animal {
    // 重写父类的eat方法
    @Override
    public void eat() {
        System.out.println("Dog is eating bones...");
    }
    
    // 新增子类的方法
    public void bark() {
        System.out.println("Dog is barking...");
    }
}

// 创建一个子类Cat，继承自Animal
public class Cat extends Animal {
    // 重写父类的sleep方法
    @Override
    public void sleep() {
        System.out.println("Cat is sleeping on the sofa...");
    }
    
    // 新增子类的方法
    public void purr() {
        System.out.println("Cat is purring...");
    }
}

// 入口方法
public static void main(String[] args) {
    // 创建一个Dog对象
    Dog dog = new Dog();
    
    // 通过子类对象调用继承自父类的方法
    dog.eat();  // 调用子类重写的eat方法
    dog.sleep(); // 调用父类的sleep方法
    dog.bark(); // 调用子类自己的方法
    
    // 创建一个Cat对象
    Cat cat = new Cat();
    
    // 通过子类对象调用继承自父类的方法
    cat.eat(); // 调用父类的eat方法
    cat.sleep(); // 调用子类重写的sleep方法
    cat.purr(); // 调用子类自己的方法
}

在上述示例中，我们创建了一个父类Animal，该类有两个公开的方法eat()和sleep()。然后我们创建了两个子类Dog和Cat，分别继承自Animal类。在子类中，我们重写了父类的eat()和sleep()方法，并且新增了属于子类自己的方法bark()和purr()。

在主方法中，我们创建了一个Dog对象和一个Cat对象，并分别通过这两个子类对象调用继承自父类的方法和子类自己的方法。通过运行程序，我们可以看到不同子类对象调用相同的方法时，表现出不同的行为。

最后我们来学习多态：

// 创建一个父类Animal
public class Animal {
    // 公开的方法
    public void makeSound() {
        System.out.println("Animal is making a sound...");
    }
}

// 创建一个子类Dog，继承自Animal
public class Dog extends Animal {
    // 重写父类的方法
    @Override
    public void makeSound() {
        System.out.println("Dog is barking...");
    }
}

// 创建一个子类Cat，继承自Animal
public class Cat extends Animal {
    // 重写父类的方法
    @Override
    public void makeSound() {
        System.out.println("Cat is meowing...");
    }
}

// 入口方法
public static void main(String[] args) {
    // 创建一个Animal类型的引用，指向一个Dog对象
    Animal dog = new Dog();
    
    // 通过父类引用调用makeSound方法，实际执行的是子类Dog的方法
    dog.makeSound(); // 输出：Dog is barking...
    
    // 创建一个Animal类型的引用，指向一个Cat对象
    Animal cat = new Cat();
    
    // 通过父类引用调用makeSound方法，实际执行的是子类Cat的方法
    cat.makeSound(); // 输出：Cat is meowing...
}

在上述示例中，我们创建了一个父类Animal，该类有一个公开的方法makeSound()。然后我们创建了两个子类Dog和Cat，分别继承自Animal类，并且分别重写了父类的makeSound()方法。

在主方法中，我们创建了一个Animal类型的引用dog，指向一个Dog对象，和一个Animal类型的引用cat，指向一个Cat对象。然后通过这两个父类引用分别调用makeSound()方法。尽管我们声明的引用类型都是父类Animal，但由于多态的特性，实际执行的是子类Dog和Cat中重写的方法。

通过运行程序，我们可以看到不同类型的对象调用相同的方法时，表现出不同的行为。这就是多态的效果。

2.Java面向对象的抽象类：

// 创建一个抽象类Animal
public abstract class Animal {
    // 抽象方法
    public abstract void makeSound();
    
    // 具体方法
    public void sleep() {
        System.out.println("Animal is sleeping...");
    }
}

// 创建一个子类Dog，继承自Animal
public class Dog extends Animal {
    // 实现抽象方法
    @Override
    public void makeSound() {
        System.out.println("Dog is barking...");
    }
}

// 创建一个子类Cat，继承自Animal
public class Cat extends Animal {
    // 实现抽象方法
    @Override
    public void makeSound() {
        System.out.println("Cat is meowing...");
    }
}

// 入口方法
public static void main(String[] args) {
    // 创建一个Animal类型的引用，指向一个Dog对象
    Animal dog = new Dog();
    
    // 通过父类引用调用makeSound方法，实际执行的是子类Dog的方法
    dog.makeSound(); // 输出：Dog is barking...
    
    // 创建一个Animal类型的引用，指向一个Cat对象
    Animal cat = new Cat();
    
    // 通过父类引用调用makeSound方法，实际执行的是子类Cat的方法
    cat.makeSound(); // 输出：Cat is meowing...
    
    // 通过父类引用调用具体方法sleep
    dog.sleep(); 
    cat.sleep(); 
}

在上述示例中，我们创建了一个抽象类Animal，该类有一个抽象方法makeSound()和一个具体方法sleep()。然后我们创建了两个子类Dog和Cat，分别继承自Animal类，并且分别实现了父类的抽象方法。子类Dog和Cat可以根据自身的特性定义自己的makeSound()实现。

在主方法中，我们创建了一个Animal类型的引用dog，指向一个Dog对象，和一个Animal类型的引用cat，指向一个Cat对象。然后通过这两个父类引用分别调用makeSound()和sleep()方法。尽管我们声明的引用类型都是父类Animal，但由于多态的特性，实际执行的是子类Dog和Cat中实现的方法。

通过运行程序，我们可以看到不同类型的对象调用相同的方法时，表现出不同的行为。抽象类定义了某个类的抽象概念和行为，子类通过实现父类的抽象方法来具体化这些行为。而具体方法则提供了一些通用的行为，可以直接使用或在子类中重写。

3.Java面向对象的接口：

// 创建一个接口Animal
public interface Animal {
    // 抽象方法
    public void makeSound();
    
    // 默认方法
    public default void sleep() {
        System.out.println("Animal is sleeping...");
    }
    
    // 静态方法
    public static void breathe() {
        System.out.println("Animal is breathing...");
    }
}

// 创建一个实现接口Animal的类Dog
public class Dog implements Animal {
    // 实现接口的抽象方法
    @Override
    public void makeSound() {
        System.out.println("Dog is barking...");
    }
}

// 创建一个实现接口Animal的类Cat
public class Cat implements Animal {
    // 实现接口的抽象方法
    @Override
    public void makeSound() {
        System.out.println("Cat is meowing...");
    }
}

// 入口方法
public static void main(String[] args) {
    // 创建一个Animal类型的引用，指向一个Dog对象
    Animal dog = new Dog();
    
    // 通过接口引用调用makeSound方法，实际执行的是子类Dog的实现
    dog.makeSound(); // 输出：Dog is barking...
    
    // 创建一个Animal类型的引用，指向一个Cat对象
    Animal cat = new Cat();
    
    // 通过接口引用调用makeSound方法，实际执行的是子类Cat的实现
    cat.makeSound(); // 输出：Cat is meowing...
    
    // 通过接口调用默认方法和静态方法
    dog.sleep(); // 输出：Animal is sleeping...
    Animal.breathe(); // 输出：Animal is breathing...
}

在上述示例中，我们创建了一个接口Animal，该接口有一个抽象方法makeSound()、一个默认方法sleep()和一个静态方法breathe()。

然后我们创建了两个实现接口Animal的类Dog和Cat，并分别实现了接口的抽象方法。这两个类必须提供makeSound()方法的具体实现。

在主方法中，我们创建了一个Animal类型的引用dog，指向一个Dog对象，和一个Animal类型的引用cat，指向一个Cat对象。然后通过这两个接口引用分别调用makeSound()方法，实际执行的是子类Dog和Cat的实现。

接口和抽象类都可以定义抽象方法，但接口只能定义抽象方法，并且不能包含具体实现。接口还可以定义默认方法和静态方法。

通过运行程序，我们可以看到不同类型的对象调用相同的方法时，表现出不同的行为。接口定义了某个类的能力（方法），实现该接口的类必须提供这些能力的具体实现。接口的默认方法和静态方法可以提供一些通用的行为或功能，可以直接使用。

4.最后是Java面向对象异常的学习：

public class Calculator {
    public double divide(int num1, int num2) throws ArithmeticException {
        if (num2 == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        
        return (double) num1 / num2;
    }
    
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        
        try {
            double result = calculator.divide(10, 0);
            System.out.println("计算结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("发生异常：" + e.getMessage());
        }
    }
}

在上述示例中，我们创建了一个Calculator类，其中有一个divide()方法用于计算两个数的商。在divide()方法中，我们首先检查除数是否为0，如果是，则抛出一个ArithmeticException的异常，异常消息为"除数不能为0"。否则，计算两个数的商并返回。

在主方法中，我们创建了一个Calculator对象，并调用divide()方法计算10除以0的结果。由于除数为0，会抛出ArithmeticException异常。我们使用try-catch块来捕获并处理异常，当捕获到ArithmeticException异常时，会打印异常消息。

通过运行程序，我们可以看到当除数为0时，会抛出异常并打印异常消息。通过异常处理，我们可以在程序中处理可能出现的异常情况，使程序更加健壮。

2301_80070214
关注
  • 23
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Vue学习笔记（尚硅谷天禹老师）
qq_55593227的博客
08-15 31万+
Vue学习笔记（尚硅谷天禹老师讲解） 1. Vue核心 1.1. Vue简介 1.1.1. 官网 英文官网 中文官网 1.1.2. 介绍与描述 动态构建用户界面的渐进式JavaScript框架 作者：尤雨溪 1.1.3. Vue的特点 遵循MVVM模式 编码简洁，体积小，运行效率高，适合移动/PC端开发 它本身只关注UI，可以引入其它第三方库开发项目 1.1.4.与其他JS框架的关联 借鉴 Angular 的模板和数据绑定技术 借鉴 React 的组件化和虚拟DOM
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
Java中的设计模式之工厂模式
u013208623的博客
12-22 277
工厂模式是一种设计模式，它可以帮助你创建对象。工厂模式把对象的创建过程封装在一个独立的工厂类中，并提供一个公共的接口用于创建对象。
JavaSE学习总结（三）
m0_51431003的博客
06-29 104
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型(而不是引用变量的类型)决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。前两者都需要显式地调用构造方法。
定义一个接口 Animal，其中包含一个方法 makeSound()。创建两个抽象类 Mammal 和 Bird，它们都实现 Animal 接口。在这两个抽象类中，实现 makeSound() 方法。
xi1666666的博客
11-30 792
【代码】定义一个接口 Animal，其中包含一个方法 makeSound()。创建两个抽象类 Mammal 和 Bird，它们都实现 Animal 接口。在这两个抽象类中，实现 makeSound() 方法。
Elasticsearch学习笔记
热门推荐
KISS
04-15 26万+
- - - - 第1章 Elasticsearch概述 - 01-开篇 02-技术选型 03-教学大纲 - 第2章 Elasticsearch入门 - 04-入门-环境准备 05-入门-RESTful & JSON 06-入门-Postman客户端工具 07-入门-倒排索引 08-入门-HTTP-索引-创建 09-入门-HTTP-索引-查询 & 删除 10-入门-HTTP-文档-创建（Put & Post） 11-入门-HTTP-查询-主键查询 &...
C++学习笔记
ftm_csdn的博客
04-16 1万+
C++是C语言的超集。
Spring5学习笔记汇总
分享思想，留下痕迹。
10-31 1万+
大家好，我是Leo哥🫣🫣🫣，前前后后，3个月，断断续续的，终于把孙哥Spring5系列视频看完了，也是陆续把笔记补充上来了。全网最细的Spring系列教程，带你由浅入深的学习Spring，有广度，也有深度。还是那句话，不是你学不会，而是你没找对人。
CSS学习笔记
Curry_On的博客
10-26 2268
CSS学习笔记 本文根据B站pink老师视频整理，供复习参考 笔记内容（更新中）：
软件工程学习笔记
快乐江湖的博客
02-05 4万+
【专栏必读】王道考研408操作系统万字笔记（有了它不需要你再做笔记了）：各章节内容概述导航和思维导图 【专栏必读】王道考研408数据结构万字笔记（有了它不需要你再做笔记了）：各章节内容概述导航和思维导图 【专栏必读】王道考研408计算机组成原理万字笔记（从学生角度辅助大家理解）：各章节导航及思维导图 【README】Linux系统编程必读：本专栏内容提要以及系统调用接口总结 C++学习 【专栏必读】数据库系统概论第五版（王珊）专栏学习笔记目录导航 注意： 可看视频介绍： 本专栏笔记全部纯手打，内容以.
机器学习笔记整理
ShaneHolmes
07-09 2913
关于我的Github 以下是机器学习部分的学习笔记的集合整理： 1.《机器学习前言之基本概念》 2.《机器学习之决策树》 3.《机器学习之最邻近规则分类KNN》 4.《机器学习之支持向量机SVM(一)》 5.《机器学习之支持向量机SVM(二)》 6.《机器学习之神经网络NN》 7.《机器学习之简单线性回归》 8.《机器学习之多元线性回归》 9.《机器学习之目标函数，损失函数和代价函数》 10.《机...
学习笔记学习笔记学习笔记
01-29
学习笔记学习笔记学习笔记
MAKE 学习 笔记make
04-22
MAKE学习笔记
GCC 学习 笔记GCC学习笔记
04-22
GCC学习笔记
PHP个人学习笔记
03-13
PHP个人学习笔记
编程学习之路：从零到一的成长指南
最新发布
KsuferNotes
07-22 410
在当今数字化时代，编程技能已经成为许多人职业发展的重要组成部分。不论你是已经在IT业从业多年的老手，还是刚刚起步的编程新手，这篇博客将带你走过编程学习的每一个重要阶段，从而顺利完成从零到一的华丽转变。
kubernetes学习日志（七）
qq_47037022的博客
07-18 630
本文记录了service管理，ingress管理，Dashboard管理插件，集群鉴权策略，角色与全局角色，赋权与全局角色赋权。
手写简易版Spring IOC容器02【学习】
weixin_44794897的博客
07-19 587
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
昇思25天学习打卡营第16天|munger85
MungerVC
07-20 446
MobileNet网络是由Google团队于2017年提出的专注于移动端、嵌入式或IoT设备的轻量级CNN网络，相比于传统的卷积神经网络首先安装依赖下载数据。
C99编程语言学习笔记
"C语言学习笔记，来自GitHub的开源学习资料，包括C99标准的学习、高级主题、系统知识以及常用工具的使用" 这篇C语言学习笔记涵盖了从基础到高级的各种主题，适合C语言初学者及有一定经验的开发者进行深入学习。笔记...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值