面向对象学习

已于 2023-08-02 11:12:27 修改
阅读量44 收藏
点赞数
文章标签： 学习 服务器 运维
于 2023-08-01 20:08:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SHX20010129/article/details/131925543
版权

1 面向对象概述

1.1 面向对象和面向过程

  1. 面向对象：Object Oriented Programming
    面向过程，强调的是功能行为，以函数为最小单位
  2. 面向过程：Procedure Oriented Programming
    面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚
    合、多态等。
  3. 面向对象的三大特征
    封装 (Encapsulation)
    继承 (Inheritance)
    多态 (Polymorphism)

1.1.1 七大原则

  1. 单一职责原则（Single Responsibility Principle）
    每一个类应该专注于做一件事情。
  2. 里氏替换原则（Liskov Substitution Principle）
    超类存在的地方，子类是可以替换的。
  3. 依赖倒置原则（Dependence Inversion Principle）
    实现尽量依赖抽象，不依赖具体实现。
  4. 接口隔离原则（Interface Segregation Principle）
    应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。
  5. 迪米特法则（Law Of Demeter）
    又叫最少知识原则，一个软件实体应当尽可能少的与其他实体发生相互作用。
  6. 开闭原则（Open Close Principle）
    面向扩展开放，面向修改关闭。
  7. 组合/聚合复用原则（Composite/Aggregate Reuse Principle CARP）
    尽量使用合成/聚合达到复用，尽量少用继承。原则： 一个类中有另一个类的对象。

1.2 概述

类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
类（Class）是一种抽象的数据类型，用于封装数据和方法。它定义了一类对象的通用属性和行为。类是创建对象的模板，描述了对象应该具有的属性和方法。可以将类看作是一种蓝图或模型，用来创建具体的对象。

对象（Object）是类的实例化结果，是具体存在的实体。对象是类的具体实例，具有类定义的属性和行为。每个对象都有自己的状态（属性值）和行为（方法），并且可以独立地进行操作。

举个例子，可以将类比作“学生”，而对象就是具体的每个学生。类定义了学生的属性（如姓名、年龄、性别）和行为（如学习、考试），而每个具体的学生对象就是根据类创建出来的实例，拥有自己的属性和行为。

类和对象之间的关系是类是对象的抽象，而对象是类的具体实例。通过创建对象，可以利用类定义的属性和方法来进行具体的操作和处理。

总结起来，类是一种抽象的模板或定义，描述了对象的通用属性和行为；而对象是类的实例，具体存在的实体，拥有自己的状态和行为。类和对象是面向对象编程中非常重要的概念，通过它们可以实现封装、继承和多态等面向对象的特性。

1.3 类的成员

1.3.1 属性

属性（Fields）：属性是类的成员变量，用于存储对象的状态或数据。属性可以是各种数据类型，如整数、字符串、布尔值等。每个对象都有自己的属性值。属性可以是公共的（public），可以被类的外部访问；也可以是私有的（private），只能在类的内部访问。通过属性，可以描述对象的特征和状态。

1.3.2 方法

方法（Methods）：方法是类的成员函数，用于定义类对象的行为或操作。方法可以执行特定的任务，可以访问和修改属性的值，并可以返回结果。方法可以接受参数，用于传递数据给方法进行处理。方法也可以是公共的或私有的，控制对外部的访问权限。

1.4 内存解析

1.4.1 创建对象

class Person{
int age;
void shout(){
System.out.println(“oh,my god! I am ” + age);
}
}

在这里插入图片描述

1.4.2 使用对象

class PersonTest{
public static void main(String[] args) { //程序运行的内存布局如下图
Person p1 = new Person();
Person p2 =new Person();
p1.age = -30;
p1.shout();
p2.shout();
}
}

在这里插入图片描述

1.4.3 内存区域

在这里插入图片描述
堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内
存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译
期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、
double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。 方法
执行完，自动释放。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编
译后的代码等数据。

1.5 属性

1.5.1 变量的分类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class Person {
private int i;
short s;
private char c;
String str;
int[] arr;
@Override
public String toString() {
return ""+ i + s + (int)c + str + arr;
}
public static void main(String[] args) {
System.out.println(new Person());
}
}
//结果 000nullnull

1.6 方法

格式：

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码
return 返回值;
｝

/*
* 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
*/
//测试类
public class CircleTest {
public static void main(String[] args) {
Circle c1 = new Circle();
c1.radius = 2.1;
//对应方式一：
// double area = c1.findArea();
// System.out.println(area);
//对应方式二：
c1.findArea();
}
}
//圆
class Circle{
//属性
double radius;
//求圆的面积
//方式一：
// public double findArea(){
// double area = Math.PI * radius * radius;
// return area;
// }
//方式二：
public void findArea(){
double area = Math.PI * radius * radius;
System.out.println("面积为：" + area);
}
}

1.6.1 方法的重载

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

public class PrintStream {
public static void print(int i) {……}
public static void print(float f) {……}
public static void print(String s) {……}
public static void main(String[] args) {
print(3);
print(1.2f);
print("hello!");
}
}

编写程序，定义三个重载方法并调用。方法名为mOL。

  • 三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果， 相乘并输出结果，输出字符串信息。
  • 在主类的main ()方法中分别用参数区别调用三个方法。
    定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值，并分别调用三个方法。
public class OverloadExer {
//1. 如下的三个方法构成重载
public void mOL(int i){
System.out.println(i * i);
}
public void mOL(int i,int j){
System.out.println(i * j);
}
public void mOL(String s){
System.out.println(s);
}
//2.如下的三个方法构成重载
public int max(int i,int j){
return (i > j)? i : j;
}
public double max(double d1,double d2){
return (d1 > d2)? d1 : d2;
}
public double max(double d1,double d2,double d3){
double max = (d1 > d2)? d1 : d2;
return (max > d3)? max : d3;
}
}

1.6.2 可变参数

  1. 声明格式：方法名(参数的类型名 …参数名)
  2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
  3. 可变个数形参的方法与同名的方法之间，彼此构成重载
  4. 可变参数方法的使用与方法参数部分使用数组是一致的
    5. 方法的参数部分有可变形参，需要放在形参声明的最后
  5. 在一个方法的形参位置，最多只能声明一个可变个数形参
public class Test2 {
public void show(String[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public void display(String... arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public void display(String name, int... arr) {
System.out.println("name=" + name);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void main(String[] args) {
Test2 t2 = new Test2();
String[] strs = new String[] {"a", "b", "c"};
t2.show(strs);
System.out.println("--------------");
String[] strs2 = new String[] {"aa", "bb", "cc"};
t2.display(strs2);
System.out.println("--------------");
//可变参数用法
t2.display();
// t2.show(); //报错
System.out.println("--------------");
t2.display("mickey", "a", "b");
t2.display("mickey", 1, 2, 3);
}
}

1.6.3 参数传递

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

  • 形参：方法声明时的参数
  • 实参：方法调用时实际传给形参的参数值
    1.基本数据类型参数传递
public static void main(String[] args) {
int x = 5;
System.out.println("修改之前x = " + x);// 5
// x是实参
change(x);
System.out.println("修改之后x = " + x);// 5
}
public static void change(int x) {
System.out.println("change:修改之前x = " + x);
x = 3;
System.out.println("change:修改之后x = " + x);
}

2.引用类型参数传递

public static void main(String[] args) {
Person obj = new Person();
obj.age = 5;
System.out.println("修改之前age = " + obj.age);// 5
// x是实参
change(obj);
System.out.println("修改之后age = " + obj.age);// 3
}
public static void change(Person obj) {
System.out.println("change:修改之前age = " + obj.age);
obj.age = 3;
System.out.println("change:修改之后age = " + obj.age);
}
其中Person类定义为：
class Person{
int age;
}

public static void main(String[] args) {
Person obj = new Person();
obj.age = 5;
System.out.println("修改之前age = " + obj.age);// 5
// x是实参
change(obj);
System.out.println("修改之后age = " + obj.age);// 5
}
public static void change(Person obj) {
obj = new Person();
System.out.println("change:修改之前age = " + obj.age);
obj.age = 3;
System.out.println("change:修改之后age = " + obj.age);
}
//其中Person类定义为：
class Person{
int age;
}

1.6.4 递归法

递归方法：一个方法体内调用它自身。

  • 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
  • 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
public class RecursionTest {
public static void main(String[] args) {
// 例1：计算1-100之间所有自然数的和
// 方式一：
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
// 方式二：
RecursionTest test = new RecursionTest();
int sum1 = test.getSum(100);
System.out.println(sum1);
System.out.println("*****************");
int value = test.f(10);
System.out.println(value);
}
// 例1：计算1-n之间所有自然数的和
public int getSum(int n) {// 3
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
// 例2：计算1-n之间所有自然数的乘积:n!
public int getSum1(int n) {
if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}
}
}

2 面向对象基础

2.1 封装

我们程序设计追求“高内聚，低耦合”。

  • 高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
  • 低耦合 ：仅对外暴露少量的方法用于使用。
class Animal {
public int legs;
public void eat(){
System.out.println("Eating");
}
public void move(){
System.out.println("Moving.");
}
}
public class Zoo {
public static void main(String args[]) {
Animal xb = new Animal();
xb.legs = 4; //问题：xb.legs = -1000，解决方式将legs属性封装起来，防止乱用
System.out.println(xb.legs);
xb.eat();
xb.move();
}
}

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()**和setXxx()**实现对该属性的操作，以实现下述目的：

  • 隐藏一个类中不需要对外提供的实现细节；
  • 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操 作；
  • 便于修改，增强代码的可维护性；
class Animal {
private int legs;// 将属性legs定义为private，只能被Animal类内部访问
public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
if (i != 0 && i != 2 && i != 4) {
System.out.println("Wrong number of legs!");
return;
}
legs = i;
}
public int getLegs() {
return legs;
}
}
public class Zoo {
public static void main(String args[]) {
Animal xb = new Animal();
xb.setLegs(4); // xb.setLegs(-1000);
//xb.legs = -1000; // 非法
System.out.println(xb.getLegs());
}
}

2.2 构造函数

构造器的特征

  • 它具有与类相同的名称
  • 它不声明返回值类型。（与声明为void不同）
  • 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用：创建对象；给对象进行初始化

  • 如：Order o = new Order(); Person p = new Person(“Peter”,15);
  • 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他 们要“洗澡”了
    例1：
public class Animal {
private int legs;
// 构造器
public Animal() {
legs = 4;
}
public void setLegs(int i) {
legs = i;
}
public int getLegs() {
return legs;
}
}

根据参数不同，构造器可以分为如下两类：

  • 隐式无参构造器（系统默认提供
  • 显式定义一个或多个构造器（无参、有参）

Java语言中，每个类都至少有一个构造器
默认构造器的修饰符与所属类的修饰符一致
一旦显式定义了构造器，则系统不再提供默认构造器
一个类可以创建多个重载的构造器
父类的构造器不可被子类继承
例2：
创建程序,在其中定义两个类：Person和PersonTest类。定义如下：用setAge()设置人的合法年龄
(0~130)，用getAge()返回人的年龄。

  • 前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。
  • 修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值 和name属性值。
public class Person {
private int age;
private String name;
public Person(){
age = 18;
}
public Person(String n,int a){
name = n;
age = a;
}
public void setAge(int a){
if(a < 0 || a > 130){
// throw new RuntimeException("传入的数据非法！");
System.out.println("传入的数据非法！");
return;
}
age = a;
}
public int getAge(){
return age;
}
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
}
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.setAge(12);
System.out.println("年龄为：" + p1.getAge());
Person p2 = new Person("Tom", 21);
System.out.println("name = " + p2.getName() + ",age = " +
p2.getAge());
}
}

例3：
1：定义Student类,有4个属性：

  • String name;
  • int age;
  • String school;
  • String major;:

2 定义Student类的3个构造器:

  • 第一个构造器Student(String n, int a)设置类的name和age属性；
  • 第二个构造器Student(String n, int a, String s)设置类的name, age 和school属性；

第三个构造器Student(String n, int a, String s, String m)设置类的name, age ,school和major
属性；

  • 在main方法中分别调用不同的构造器创建的对象，并输出其属性值。

截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位置，并指明赋值的先后顺
序。

  • ① 默认初始化
  • ② 显式初始化
  • ③ 构造器中初始化
  • ④ 通过“对象.属性“或“对象.方法”的方式赋值

2.3 JAVABean

所谓javaBean，是指符合如下标准的Java类：

  • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性，且有对应的get、set方法
public class JavaBean {
private String name; // 属性一般定义为private
private int age;
public JavaBean() {
}
public int getAge() {
return age;
}
public void setAge(int a) {
age = a;
}
public String getName() {
return name;
}
public void setName(String n) {
name = n;
}
}

2.4 this关键词

在Java中，this关键字比较难理解，它的作用和其词义很接近。

  • 它在方法内部使用，即这个方法所属对象的引用；
  • 它在构造器内部使用，表示该构造器正在初始化的对象。

this 可以调用类的属性、方法和构造器

  • 当在方法内需要用到调用该方法的对象时，就用this。
  • 具体的：我们可以用this来区分属性和局部变量。比如：this.name = name;
    例1：
class Person{ // 定义Person类
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public void getInfo(){
System.out.println("姓名：" + name) ;
this.speak();
}
public void speak(){
System.out.println(“年龄：” + this.age);
}
}

例2：

class Person{ // 定义Person类
String name;
Person(String name){
this.name = name;
}
public void getInfo(){
System.out.println("Person类 --> " + this.name) ;
}
public boolean compare(Person p){
return this.name==p.name;
}
}
public class PersonTest{
public static void main(String args[]){
Person per1 = new Person("张三") ;
Person per2 = new Person("李四") ;
per1.getInfo() ; // 当前调用getInfo()方法的对象是per1
per2.getInfo() ; // 当前调用getInfo()方法的对象是per2
boolean b = per1.compare(per2);
}
}

2.5 package和import

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)，包通常用小写单词标识。通常使用所在公司域名的倒置： com.lxs.xxx

  • 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
  • 包可以包含类和子包，划分项目层次，便于管理
  • 解决类命名冲突的问题
  • 控制访问权限
package com.lxs.demo;
import javax.servlet.*;
import java.io.PrintWriter;
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
}

Java中常用的包

  1. java.lang----包含一些Java语言的核心类， 如String、 Math、 Integer、 System和Thread， 提供常用功能
  2. java.net----包含执行与网络相关的操作的类和接口。
  3. java.io ----包含能提供多种输入/输出功能的类。
  4. java.util----包含一些实用工具类， 如定义系统特性、 接口的集合框架类、 使用与日期日历相关的函数。
  5. java.text----包含了一些java格式化相关的类
  6. java.sql----包含了java进行JDBC数据库编程的相关类/接口
  7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits） 的多个类， 这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S
SHX20010129
关注
【Java面向对象学习】一张图搞定Java面向对象
monkey518的博客
09-13 4347
刚开始学习Java的时候，一个人跌跌撞撞摸索着往前走，很多东西理解的也懵懵懂懂，后来实践的多了，才慢慢清楚；许多东西虽然很基础但是却很重要，是需要反复思考和加深理解的。【Java面向对象学习】一张图搞定Java面向对象，分享一些归纳总结后的技术干货，一张图能搞定的事，绝对不长篇大论。 大家都知道，Java面向对象是Java的一个核心，也是初学者的一个难点，所以我们从这里开始，Let’s go
【LabVIEW面向对象】学习路线图
HOHO333的专栏
12-13 2640
众所周知，面向对象的程序设计是一种设计思想，它不依托于某种编程语言。C++、C#、LabVIEW都可以使用这种模式进行编程。同样的，面向对象编程设计也是近几年LabVIEW软件版本升级的主要方向，比如LabVIEW2020版本就新增了接口类和多继承的支持，相信基于面向对象的LabVIEW编程是未来的发展趋势。 相比C#等文本语言由于LabVIEW工程师的数量较少，国内几乎找不到什么像样的资料。虽说各个语言的编程思想是相通的，但面向对象在具备思想的同时，还需要一些编译器的底层支持（比如写PLC程序就没办法完
JAVA面向对象学习心得
a18786923310的博客
07-25 1863
java面向对象的知识归纳，包括（继承、封装、多态）等面向对象的特性的总结。
python面向对象基础学习总结
我的个人博客
10-05 1177
python面向对象三大特性、继承、封装、多态、类属性与实例属性、类方法与静态方法、魔法函数、私有权限
C++面向对象学习笔记二
qq_74729280的博客
05-07 1180
本文是C++面向对象程序设计的一些知识摘要，主要摘录阅读文章我所不欠缺的地方，或者有所感悟或者发现哪些问题。本文主要简单看了多继承与虚基类介绍了下多继承的情况和虚基类推荐学习博客。
面向对象再学习
郝老三~~~~~~~~~~~~~
05-05 1万+
面向对象编程是一种强大的编程范式，它具有三大特征：封装、继承和多态，以及基础的抽象概念。在面向对象编程的设计过程中，注重对象是非常重要的。我们应该尽可能将对象抽象成类，并考虑类之间的关系和行为。通过封装、继承和多态，我们可以更好地组织代码，提高代码的可重用性和可维护性。
Java面向对象浅谈
编程界明世隐的博客
12-06 5022
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
java面向对象学习心得
idreamit的博客
07-11 3159
一开始接触的语言是C语言，面向过程，感觉还是比较简单的。以为java的学习会比较困难，但是对于面向对象的这种语言还是比较容易上手的。感觉比C语言还要简单，花又说回来，对于语言没有容易简单，只要掌握了其中的方法和途径也都是一样的了，不再语言，重在掌握其中的方法。但是java对我的吸引力远远高于其他语言对我的吸引力，对于目标的明确让我时刻知道自己在干嘛，自己敲的代码最终要实现什么变得相当明确。这是最吸
面向对象学习笔记1 - 人狗大战
热门推荐
我思故我在！
04-01 3万+
人狗大战 - 人可以有多条狗，每条狗有不同的属性,如名字，品种，攻击力 - 可以有多个人，人有年龄，姓名等属性 - 狗可以咬人，人可以打狗 dog1 = { "dog_name":"mjj" "dog_type":"京巴" "dog_attack_val":30 "life_value":100 } dog2= { "dog_name":"ZO" "dog_type":"藏耦" "dog_attack_val":80 "life_v
C 语言面向对象思想
lzs940320的博客
10-22 3602
注：本博客参考了很多大神的文章加上自己的理解，只做学习复习用 一. C语言面向对象设计引入 1.我们为什么要学习面向对象思想？？？ 在我们平时的开发中也经常会遇到一些简单的项目我们很快就完成了，并且测试着也没有任何问题，但是随着产品迭代，需求增加，项目维护起来越来越耗时，一个看似简单的需求，需要花费较多的时间去开发，出现项目延期。 项目超期的很大一部分原因都是因为代码“牵一发动全身”，当我们的项目需求在累加的过程中，功能相近的应用我们也习惯性的复制，粘贴。导致出现了很多的冗余代码，同时业务逻辑与执.
易语言源码易语言面向对象学习（三）.rar
02-22
易语言源码易语言面向对象学习（三）.rar 易语言源码易语言面向对象学习（三）.rar 易语言源码易语言面向对象学习（三）.rar 易语言源码易语言面向对象学习（三）.rar 易语言源码易语言面向对象学习（三）.rar ...
CHJava核心思想面向对象学习教案.pptx
09-30
CHJava核心思想面向对象学习教案.pptx
易语言面向对象编程 面向对象学习
02-13
易语言面向对象学习 1 一．枯燥的理论 2 1．对象和类 2 2．类的“成员”与“方法” 2 3．实例化 2 4．继承 3 二．牛刀小试 3 1．定义一个类，生成实例对象 3 2．“_初始化” 与 “_销毁” 5 三．一个更丰富的“员工...
es6面向对象学习笔记整理版.md
06-16
md文件，可用Typora软件打开编辑。### 1....- ###### 面向对象编程OOP（Object Oriented programming） - 含义：把事务分解成一个个对象，通过对象之间分工与合作解决；（**拟人化，把万物写活**）
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 827
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
看Threejs好玩示例，学习创新与技术(二)
最新发布
htsitr2的专栏
09-14 343
它的主要特点是确保生成的点之间保持一定的最小距离，从而避免点的聚集。这种方法在计算机图形学、游戏开发、物理模拟等领域中非常有用，尤其是在需要生成自然分布的对象（如树木、石头等）时。如果不进行裁剪，那么效果如下（初步的锯齿感是因为矩形内采样的结果）。为啥这么复杂呢，为啥不开始存储每个方块的UV呢？下面代码的vTexCoords（=savedModelMatrix，已修改）记录方块所在的位置，vWorldPosition表示方块中像素的偏移。在上面那副图中，聪明的你一定初步猜到了每个方块的纹理是怎么得到的。
计算几何学习
网安小白
09-12 436
学习计算几何过程中对经典算法的记录
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
2401_84466224的博客
09-11 907
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
java面向对象学习
10-19
好的，关于 Java 面向对象学习，我可以为您提供一些基础知识和学习建议。首先，Java 是一种面向对象的编程语言，它的核心思想是将现实世界中的事物抽象成对象，通过对象之间的交互来完成程序的功能。 在 Java 中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值