java的类和继承构造

 一些小技巧

类和对象

什么是类，对象，方法？

在下面的 Java 代码中，定义了一个名为 Person 的类，并提供了构造方法来初始化对象的属性。类中定义了 eat、sleep 和 work 三个方法，用于表示人的行为。在 main 方法中，创建了一个名为 p1 的 Person 对象，并调用了其方法来展示人的行为。

通过这样的代码组织，我们可以创建多个不同的 Person 对象，每个对象都有自己独立的属性和行为。

public class Person {
    //属性
    private String name;
    private int age;
    private String gender;

    
    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }


    //方法，也就是行为
    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }

    public void work() {
        System.out.println(name + " is working.");
    }

    public static void main(String[] args) {
        //实例化了一个p1的对象
        Person p1 = new Person("Tom", 25, "male");
        p1.eat();
        p1.sleep();
        p1.work();
    }
}

1）在java中，类只支持单继承，不允许多重继承，也就是说，一个类只能有一个直接的父亲，例如下面这种情况是不合法的

class A{}
class B{}

class C extends A,B
//这种写法是错误的

2）但是多个类可以同时继承一个父亲

class A{}

class B extends A{}
class C extends A{}

3)多层继承也是可以的

这时候C也可以被称作A的子类

class A{}

class B extends A{}
class C extends B{}

封装

class Animal{
	private String name;
	private int age;
	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;
	}
	
}

就近原则

this指针的作用

总结

static修饰符

1.静态变量

特点：

1.可以通过类名直接访问

2.静态变量是随着类的加载而加载，是优先于对象出现的

静态变量被所有对象共享，什么意思？

下面是例子，

展示了静态变量可以通过类名访问，且被所有对象共享

调用静态变量的方法

2.静态方法

这里引入了一个新的概念——工具类，借此来整合一下目前遇到的所有类

工具类：帮助我们做一些事情，但是不描述任何事物的类。

特点：

1.见类名知其作用

2.私有化构造方法（使该类无法被示例化）

3.方法定义为静态的（不用实例化对象，也可以调用方法）

举例，计算器的类就可以被看作是工具类，因为不需要实例化对象，只需要调用方法就够了

public class ArrayUtil {
	//私有化构造方法，为了不让外界实例化对象
	private ArrayUtil() {};
	
	//定义为静态方法，方便调用
	public static void printArr(int[] arr) {
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for (int i = 0; i < arr.length; i++) {
			if(i==arr.length-1) {
				sb.append(arr[i]);
			}
			else {
				sb.append(arr[i]);
				sb.append(",");
			}
			
		}
		sb.append("]");
		
		System.out.println(sb.toString());
	}
	
	public static double getAverge(int[] arr) {
		double sum =0;
		for (int i = 0; i < arr.length; i++) {
			sum+=arr[i];
		}
		return sum/arr.length;
	}
	
	
}
public class testCalc {
	public static void main(String[] args) {
		int[] arr = {1,2,3,4,5};
		ArrayUtil.printArr(arr);
		
		double ret = ArrayUtil.getAverge(arr);
		System.out.println(ret);
	}
	
	
}

继承

继承的使用方法和好处

继承的特点

如果一个类没有父类，则默认继承于object 

可以看到，下层子类拥有上层父类的特点

继承的权限

1.子类继承了父类中的哪些内容？

总结：

1.构造方法一律不可以被继承的

2.成员变量一律可以被继承。（但是子类虽然能继承父类的private，却不能访问）

3.成员方法非私有可以被继承，私有不能被继承

2.子类能访问父类中哪些属性？

在子类中，只允许直接访问父类中非private的属性和方法，换句话说，父类中private修饰的属性和方法在子类中无法直接访问，但是可以用getter和setter方法间接访问

class Animal{//父类
    private int age;
    public int getAge(){
        return age;
    }
    String name;
}
class Dog extends Animal{//子类extends(继承)父类
    String color;
    void print(){
        System.out.println(age);//直接访问父类中的private属性，错误！
        System.out.println(name);//父类中的name为default权限，可以访问
    }
}

子类在父类基础上的操作

1.子类在父类基础上扩充属性和方法

子类已经拥有父类的所有属性和方法，扩充子类的属性和方法，让子类描述的对象更加具体

如下。Dog类示例化的对象首先会拥有Animal类的两个属性，并在此基础上扩充了一个颜色属性

class Animal{//这是父类
    int age;
    String name;
}
class Dog extends Animal{//子类extends(继承)父类
    String color;
}

2.对子类继承自父类的方法进行重写（override）

为了满足不同需求，子类可以对父类的方法重写。

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.shout();
    }
}
class Animal{//这是父类
    int age;
    String name;
    void shout(){
        System.out.println("发出了奇怪的叫声");
    }
}
class Dog extends Animal{//子类extends(继承)父类
    String color;
    void shout(){//重写
        System.out.println("发出了汪汪汪的叫声");
    }
}

注意，子类中重写方法的权限不得低于父类中原方法的权限

class Animal{//这是父类
    int age;
    String name;
    void shout(){
        System.out.println("发出了奇怪的叫声");
    }
}
class Dog extends Animal{//子类extends(继承)父类
    String color;
    private void shout(){//这样重写就错了
        System.out.println("发出了汪汪汪的叫声");
    }
}

3.虚方法表

如果A类想调用方法C，是在A类找方法C，找不到去B类找，然后再去C类找，是这样吗？

不是的，因为效率太低了，于是有了虚方法表。

对象类型转化

1.只有当两种类型有继承关系时，才能对象类型转换

2.向上类型转换。即子类转换成父类，这说无需强制类型转换的，因为父类有的东西子类肯定也有。转换完后，只能使用父类中的方法。因为已经变成父类的类型了，自然不能调用子类的方法。语法格式如下

fatherClass obj = new sonClass();

3.向下类型转换（强制类型转换）。这个操作有约束条件的。向下转型通常发生在父类类型的引用指向子类对象的情况下。确保在进行向下转型之前，引用确实指向了正确的子类对象，否则可能会出现运行时异常。

sonClass obj = (sonClass) fatherClass;

interface Animal{
	void eat();
	void sleep();
}

interface Pet extends Animal{
	void play();

	void bark();
}

class Teddy implements Pet{
	public void bark() {
		System.out.println("汪汪汪");
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃骨头");
	}

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("睡懒觉");
	}

	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("和主人玩");
	}
	
}

public class testCalc {
	public static void main(String[] args) {
		//创造Teddy对象并向上转型（无需强制类型转换）
		Pet teddy = new Teddy();
		
		teddy.eat();teddy.sleep();
		teddy.play();
		
		//teddy.bark(); 
		//这样就不行了，因为teddy现在是Pet类型，而bark方法是Teddy类里的
		
		//向下转型（强制类型转换）
		if(teddy instanceof Teddy) {
			//如果teddy此时的类型确实是Teddy类的父类
			//那么可以进行向下转型
			teddy = (Teddy)teddy;
			teddy.bark();
			
		}
		
	}
	
	
}

抽象类

1.为什么要有抽象类？

例如我们定义了一个Person类，里面的work方法是空着的（或者随便写一个，就像图中一样），这是因为，不同的人的工作是不同的，无法统一，因此无法在Person类里把work方法写好，换言之，有不确定的方法体。

需要依靠对象进行重写。

当我们去实例化老师和学生这两个对象的时候，student和teacher两个对象需要对work方法进行重写。但倘若忘记重写或没有重写，就不合适了。为了防止忘记重写的情况发生，我们要用上抽象类来“逼”对象进行重写，怎么个“逼”法？往下看。

像这样定义了一个抽象类，类中的抽象方法，子类必须强制进行重写，否则会报错。

抽象类和抽象方法的定义格式

注意！有抽象方法所在的类必须定义成抽象类！

public abstract class AbstractClass {//抽象类

    // 抽象方法
    //需要注意的是，抽象方法括号()完直接加封号;
    public abstract void abstractMethod();
    

    // 普通方法
    public void concreteMethod() {
        // 方法体
    }
}

当子类继承了抽象类之后，需要重写抽象方法。重写抽象方法的格式如下：

public class ConcreteClass extends AbstractClass {
    @Override
    public void abstractMethod() {
        // 实现抽象方法的具体逻辑
    }
}

抽象类和抽象方法的注意事项

1.抽象类不能实例化

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类可以有构造方法（可以有疑惑，既然不能实例化为什么还要有构造方法呢？因为构造方法可以用于初始化成员变量）

4.抽象类的子类，要么重写抽象类中所有的抽象方法，要么这个子类也是个抽象类

接口

为什么要有接口？

  1. 多继承：Java中的类只支持单一继承，但是通过接口，一个类可以实现多个接口，从而获得了类似于多继承的特性。这使得Java中的类能够更加灵活地组合和复用代码。同时，避免了多继承所带来的复杂性和歧义性。

  2. 解耦：接口可以将抽象和实现分离，从而降低了代码之间的耦合度。使用接口能够让程序更容易扩展和维护，因为实现类只需关注接口定义的方法即可，而不需要关心具体的实现细节。

  3. 规范约束：接口定义了一组行为规范，使得类能够按照这些规范进行设计和实现。这有助于提高代码的可读性、可维护性和可扩展性。

  4. 多态性：接口与多态性密切相关，接口的引用变量可以指向实现了该接口的任何类的对象，从而实现了对不同类的统一处理。

举个例子，现在有个游泳的功能，写到动物类里是不合适的。因为不是所有动物都会游泳，所以可以把游泳功能写成一个接口，单独提供给能游泳的动物。

abstract class Animal{
	//方法有抽象类，那么整个类也要变成抽象类
	
	private String name;
	private int age;
	
	
	
	
	public Animal() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	

	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}



	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 abstract void eat();
	//因为每个动物都有自己吃的东西，无法统一行为
	//干脆不写，直接把eat方法修饰为抽象类
	
}

//因为总共有兔子，青蛙，狗三种动物
//兔子不会游泳，所以不能把swim行为加在Animal类里
//但是如果在青蛙和狗的类里单独加Swim，可能会导致不统一
//因为青蛙里的可能叫swim，狗里的叫swimming，这就不统一了
//所以要定义一个swim接口，谁会游泳谁就继承，然后在自己的类里重写即可
interface Swim{
	public void Swim();
}

class Frog extends Animal implements Swim{

	@Override
	public void Swim() {
		System.out.println("蛙泳");
		
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃蚊子");
	}
	
}

class Dog extends Animal implements Swim{

	@Override
	public void Swim() {
		System.out.println("狗刨式");
		
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("吃骨头");
	}
	
}

class Rabbit extends Animal{

	@Override
	public void eat() {
		System.out.println("吃胡萝卜");
		
	}

	public Rabbit() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Rabbit(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	

	
	
	
}

接口的注意事项

  1. 抽象方法：接口中的方法都是抽象方法，不包含具体的实现代码；

  2. 多继承：Java中的类可以实现多个接口，这使得Java支持了接口的多继承性质；

  3. 关键字：在Java中，使用interface关键字来声明一个接口；

  4. 实现：类通过使用implements关键字来实现一个或多个接口，实现接口的类必须提供接口中定义的所有方法的具体实现；（有点像继承抽象类）

  5. 接口之间的继承：接口可以继承其他接口（但并不实现，因为接口是不包含具体的实现代码），使用extends关键字；

  6. 常量：接口中可以包含常量，这些常量默认为public static final类型；

接口和抽象类的异同

相似之处：

  1. 抽象性：接口和抽象类都是抽象的，它们不能被实例化，只能被子类实现或继承。
  2. 约束子类：它们都可以用于约束子类，使得子类必须实现或重写其中定义的方法。
  3. 实现方法：在接口和抽象类中都可以定义方法的签名而不提供具体实现。

区别：

  1. 方法实现：接口中的方法都是抽象的，没有方法体；而抽象类中可以包含抽象方法，也可以包含具体的方法实现。

  2. 多继承：在Java中，一个类只能继承一个抽象类，但可以实现多个接口。这意味着接口支持多继承，而抽象类不支持。

  3. 构造方法：抽象类可以有构造方法，而接口不能有构造方法。

  4. 成员变量：抽象类中可以包含成员变量，而接口中的变量默认为public static final类型的常量。

  5. 设计目的：抽象类用于表示一种“is-a”关系，即子类是父类的一种特殊类型；而接口更多地用于表示一种“has-a”关系，即类具有某种特定的行为能力。

综上所述，抽象类和接口在某些方面确实有相似之处，但它们的设计目的和使用场景有所不同。一般来说，如果需要表示一种层次结构，并且希望共享代码或者包含成员变量，可以使用抽象类；而如果需要表示一种行为规范，并且希望实现多重继承，可以使用接口。

该怎么规范简洁地写接口？

例题

写之前要先画图，提取共同特征到父类，特殊行为用接口实现

以下的思路对吗？是对的，但不够简洁规范。

因为父类的所有子类都应该是同一种事物，但教练和运动员不是同一种事物，因此可以再分类

修改过后，简洁很多

//因为创建人的对象是没有意义的，
//为了不让外界实例化人，修饰成抽象类
abstract class Person{
	private String name;
	private int age;
	

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public Person() {}

	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;
	};
	
	
	
}


abstract class player extends Person{
	
	
	public player() {
		super();
		// TODO Auto-generated constructor stub
	}

	public player(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	public abstract void learn(); 
	//public abstract void game(); 
}

abstract class coach extends Person{
	
	
	public coach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public coach(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	public abstract void teach(); 
	
}

interface speak{
	public abstract void speadEndlish();
}

class pingpong_Player extends player implements speak{

	
	
	public pingpong_Player() {
		super();
		// TODO Auto-generated constructor stub
	}

	public pingpong_Player(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void speadEndlish() {
		// TODO Auto-generated method stub
		System.out.println("会讲英语");
	}

	@Override
	public void learn() {
		// TODO Auto-generated method stub
		System.out.println("学打乒乓球");
	}
	
}

class basketball_Player extends player{
	

	public basketball_Player() {
		super();
		// TODO Auto-generated constructor stub
	}

	public basketball_Player(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void learn() {
		// TODO Auto-generated method stub
		System.out.println("学打篮球");
	}
	
}

class pingpong_Coach extends coach implements speak{

	
	public pingpong_Coach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public pingpong_Coach(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("教打乒乓球");
	}

	@Override
	public void speadEndlish() {
		// TODO Auto-generated method stub
		System.out.println("会讲英语");
	}
	
}

class basketball_Coach extends coach{

	
	
	public basketball_Coach() {
		super();
		// TODO Auto-generated constructor stub
	}

	public basketball_Coach(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	
	
	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("教打篮球");
	}
	
}



public class testCalc {
	public static void main(String[] args) {
		pingpong_Player p1 = new pingpong_Player("马龙",18);
		System.out.println(p1.getName()+","+p1.getAge());
		p1.learn();p1.speadEndlish();
		System.out.println("-------------------");
		
		pingpong_Coach p2 =  new pingpong_Coach("刘国强",55);
		System.out.println(p2.getName()+","+p2.getAge());
		p2.teach();p2.speadEndlish();
		System.out.println("-------------------");
		
		basketball_Player b1 = new basketball_Player("姚明",20);
		System.out.println(b1.getName()+","+b1.getAge());
		b1.learn();
		System.out.println("-------------------");
		
		basketball_Coach b2 = new basketball_Coach("姚明的教练",50);
		System.out.println(b2.getName()+","+b2.getAge());
		b2.teach();
		System.out.println("-------------------");
		
		
	}
	
	
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/136473.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

为什么Android 手机这么慢？如何提高 Android 手机的运行速度

为什么Android 手机这么慢？如何提高 Android 手机的运行速度

速印机&#xff08;理想、荣大等&#xff09;、复印机&#xff08;夏普、东芝、理光、佳能、震旦等全系列&#xff09;、打印机、扫描仪、传真机、多媒体教学一体机、交互式电子白板、报警器材、监控、竞业达监考设备及其它监考设备、听力考试设备、特种安防设备维护及维修。吴…
阅读更多...
JavaScript_动态表格_添加功能

JavaScript_动态表格_添加功能

1、动态表格_添加功能.html <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>动态表格_添加功能</title><style>table{border: 1px solid;margin: auto;width: 100%;}td,th{text-align: ce…
阅读更多...
Django 基于ORM的CURD、外键关联，请求的生命周期

Django 基于ORM的CURD、外键关联，请求的生命周期

文章目录 基于ORM进行的CURDORM外键关联Django请求的生命周期流程图 基于ORM进行的CURD 本质上就是通过面向对象的方式&#xff0c;对数据库的数据进行增、删、改、查。 这里将会将我们之前所有内容结合到一起&#xff0c;首先确保基于上序操作已经建立好了UserInfo表&#xff…
阅读更多...
odoo16 库存初始化 excel导入问题2

odoo16 库存初始化 excel导入问题2

产品导入模板： excel内容: 导入测试 查看可能的值，发现没有ml，在计量单位中增加ml选项（不选创建，知道为什么不，仔细想想，创建不知ml是什么单位） 位置不能在此导入，故取消 测试正常 导入成功 总结：产品导入时，位置无法指定，只建产品名称，计量单位，采购单位，
阅读更多...
自定义Graph Component：1.1-JiebaTokenizer具体实现

自定义Graph Component：1.1-JiebaTokenizer具体实现

JiebaTokenizer类继承自Tokenizer类&#xff0c;而Tokenizer类又继承自GraphComponent类&#xff0c;GraphComponent类继承自ABC类&#xff08;抽象基类&#xff09;。本文使用《使用ResponseSelector实现校园招聘FAQ机器人》中的例子&#xff0c;主要详解介绍JiebaTokenizer类…
阅读更多...
python工具CISCO ASA设备任意文件读取

python工具CISCO ASA设备任意文件读取

​python漏洞利用 构造payload&#xff1a; /CSCOT/translation-table?typemst&textdomain/%2bCSCOE%2b/portal_inc.lua&default-language&lang../漏洞证明&#xff1a; 文笔生疏&#xff0c;措辞浅薄&#xff0c;望各位大佬不吝赐教&#xff0c;万分感谢。 免…
阅读更多...
golang Copier 数据复制

golang Copier 数据复制

Copier I am a copier, I copy everything from one to another Copier是golang实现的&#xff0c;实现不同数据结构之间数据复制的工具包 github地址 使用方法 以User和Employee之间相互复制为例 使用的版本为 v0.3.5 入门 package mainimport ("fmt""git…
阅读更多...
DevChat 初探之 RBAC 模型的实现

DevChat 初探之 RBAC 模型的实现

今天我们来尝试一款编程辅助助手 DevChat, 看能不能提升咱们的日常编程效率。作为一款编程助手&#xff0c;我们来看看它与 Copilot, CodeWhisperer 同领域产品的一些区别和特色。定个小目标&#xff0c;通过 DevChat 实现一个简单的 RBAC 模型&#xff0c;小试牛刀一下&#x…
阅读更多...
Acer宏碁Aspire A715-75G笔记本工厂模式原厂Windows10预装OEM系统2004带恢复功能

Acer宏碁Aspire A715-75G笔记本工厂模式原厂Windows10预装OEM系统2004带恢复功能

下载链接&#xff1a;https://pan.baidu.com/s/1nJFd25lElc1VAPf_RqSDYA?pwdd05h 提取码&#xff1a;d05h 原装出厂系统自带所有驱动、Office办公软件、出厂主题壁纸、系统属性Acer宏基专属的LOGO标志、 Acer Care Center、Quick Access等预装程序 所需要工具&#xff1a…
阅读更多...
kubenetes-kubelet组件

kubenetes-kubelet组件

一、kubelet架构 每个节点都运行一个kubelet进程&#xff0c;默认监听10250端口&#xff0c;kubelet作用非常重要&#xff0c;是节点的守护神。 接收并执行 master发来的指令。管理Pod及Pod中的容器。每个kubelet进程会在API Server 上注册节点自身信息&#xff0c;定期向mast…
阅读更多...
mysql讲解2 之事务 索引 以及权限等

mysql讲解2 之事务 索引 以及权限等

系列文章目录 mysql 讲解一 博客链接 点击此处即可 文章目录 系列文章目录一、事务1.1 事务的四个原则1.2 脏读 不可重复读 幻读 二、索引三,数据库用户管理四、mysql备份 一、事务 1.1 事务的四个原则 什么是事务 事务就是将一组SQL语句放在同一批次内去执行 如果一个SQ…
阅读更多...
常见后缀名总结 为你指点迷津

常见后缀名总结 为你指点迷津

相信在日常的学习和工作中&#xff0c;大家一定会遇到各种各样的文件类型&#xff0c;他们的后缀名类型各不相同&#xff0c;诸多陌生的文件格式经常让大家不知道他们存在于电脑的意义&#xff0c;想删又没法删&#xff0c;想执行又无法执行。 今天&#xff0c;学长就带领大家一…
阅读更多...
笔记：AI量化策略开发流程-基于BigQuant平台（二）

笔记：AI量化策略开发流程-基于BigQuant平台（二）

五、模型训练股票预测 完成了数据处理&#xff0c;接下来就可利用平台集成的各算法进行模型训练和模型预测啦。本文将详细介绍“模型训练”、“模型预测”两大模块操作、原理。 模型训练和模型预测是AI策略区别于传统量化策略的核心&#xff0c;我们通过模型训练模块利用训练…
阅读更多...
c语言练习11周（6~10）

c语言练习11周（6~10）

输入任意字串&#xff0c;将串中除了首尾字符的其他字符升序排列显示&#xff0c;串中字符个数最多20个。 题干 输入任意字串&#xff0c;将串中除了首尾字符的其他字符升序排列显示&#xff0c;串中字符个数最多20个。输入样例gfedcba输出样例gbcdefa 选择排序 #include<s…
阅读更多...
每日一题(LeetCode)----数组--长度最小的子数组

每日一题(LeetCode)----数组--长度最小的子数组

每日一题(LeetCode)----数组–长度最小的子数组 1.题目&#xff08; 209.长度最小的子数组&#xff09; 给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl1, ..., numsr-1, numsr] &…
阅读更多...
深度解析找不到msvcp120.dll相关问题以及解决方法

深度解析找不到msvcp120.dll相关问题以及解决方法

​在计算机使用过程中&#xff0c;我们经常会遇到一些错误提示&#xff0c;其中之一就是“msvcp120.dll丢失”。这个错误通常会导致某些应用程序无法正常运行&#xff0c;给用户带来很大的困扰。那么&#xff0c;如何解决msvcp120.dll丢失的问题呢&#xff1f;本文将为大家介绍…
阅读更多...
手机地磁传感器与常见问题

手机地磁传感器与常见问题

在手机中&#xff0c;存在不少传感器&#xff0c;例如光距感&#xff0c;陀螺仪&#xff0c;重力加速度&#xff0c;地磁等。关于各传感器&#xff0c;虽功能作用大家都有所了解&#xff0c;但是在研发设计debug过程中&#xff0c;却总是会遇到很多头疼的问题。关于传感器&…
阅读更多...
BM65 最长公共子序列（二）

BM65 最长公共子序列（二）

动态规划 BM65 最长公共子序列&#xff08;二&#xff09; 这道题是动态规划的典型例题。 思路 题目要求获取最长公共子序列&#xff0c;我们要先求最长公共子序列的长度&#xff0c;然后根据这个长度倒推从而获取这个子序列。注意&#xff1a;子序列不是子串&#xff0c;子…
阅读更多...
C语言进阶

C语言进阶

数组 在基础篇说过&#xff0c;数组实际上是构造类型之一&#xff0c;是连续存放的。 一维数组 定义 定义格式&#xff1a;[存储类型] 数据类型 数组名标识符[下标]; 下面分模块来介绍一下数组的定义部分的内容。 1、初始化和元素引用&#xff1a; 可以看到数组是连续存储…
阅读更多...
第六章 DNS域名解析服务器

第六章 DNS域名解析服务器

1、DNS简介 DNS&#xff08;Domain Name System&#xff09;是互联网上的一项服务&#xff0c;它作为将域名和IP地址相互映射的一个分布式数据库&#xff0c;能够使人更方便的访问互联网。 DNS系统使用的是网络的查询&#xff0c;那么自然需要有监听的port。DNS使用的是53端口…
阅读更多...
最新文章

Copyright @ 2022~2023