黑马程序员——java中构造函数、继承、多态、接口总结

最新推荐文章于 2020-11-04 21:45:06 发布
最新推荐文章于 2020-11-04 21:45:06 发布
阅读量810 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanyy15083/article/details/47207539
版权
------ Java培训、Android培训 、期待与您交流！ -------

一、构造函数

     1、概念和作用
          构造函数是构建创造对象时调用的函数。构造函数可以给对象进行初始化。在主函数中创建对象时必须要通过构造函数进行初始化。一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。另外也可以在类中定义了指定的构造函数，此时创建对象时调用的是自定义的构造函数。
     2、构造函数和一般函数的区别
          构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。对象创建时，会调用只调用一次。没返回值
          一般函数：对象创建后，需要函数功能时才调用。 对象创建后，可以被调用多次。有返回值
     3、构造函数的重载
         在 Java 里，不仅一般函数可以重载，构造函数也可以重载。只要构造函数的参数个数不同，或是类型不同，便可定义多个名称相同的构造函数。 
//构造函数重载
class Person {
	private String name;
	private int age;

	public Person() {//空参数构造函数
	}

	Person(String n, int a) {//带有两个参数的构造函数
		name = n;
		age = a;
	}

	public String talk() {
		return "我是： " + name + "，今年： " + age + "岁 ";
	}
}

public class Construct {
	public static void main(String[] args) {
		Person p = new Person();//调用空参数构造函数
		System.out.println(p.talk());//打印姓名和年龄
		Person p1 = new Person("小明",20);//调用有参数构造函数并传入参数
		System.out.println(p1.talk());//打印姓名和年龄
	}
}

输出结果为：
我是： null，今年： 0岁      
我是： 小明，今年： 20岁
由结果可以看出：构造函数中String类型默认初始化值为null，int类型默认初始化值为0。

    4、this关键字

class Person {
	String name;
	int age;

	public Person() {
		System.out.println("1. public Person()");
	}

	public Person(String name, int age) {
		this();// 调用本类中无参构造方法，即Person（）｛｝，必须定义在构造函数的第一行
		this.name = name;//this表示当前对象
		this.age = age;//this表示当前对象
		System.out.println("2. public Person(String name,int age)");
	}
}

public class TestThis {
	public static void main(String[] args) {
		new Person("小明", 20);
	}
}

输出结果为：

1. public Person()
2. public Person(String name,int age)

          由此可见，this关键字可以表示当前对象，也可以在构造函数中调用另一个构造函数。


     5、static关键字

class Person {
	String name;
	private static String city = "北京";// 静态变量被所有对象共享
	int age;

	public Person() {
		System.out.println("1.public Person()");
	}

	// 此段代码会首先被执行——静态代码块
	static {
		System.out.println("2.Person 类的静态代码块被调用！ ");
	}

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

	public String talk() {
		return "我是：" + this.name + "，今年：" + this.age + "岁，来自：" + city;
	}

	// 静态方法定义的内容可以用于非静态和静态方法中使用
	// 静态方法中使用非静态方法中的内容时会报错
	public static void setCity(String c) {
		city = c;
	}
}

public class TestStatic {
	// 运行本程序时，静态代码块会被自动执行
	static {
		System.out.println("3.TestStatic 类的静态代码块被调用！ ");
	}

	public static void main(String[] args) {
		System.out.println("4.程序开始执行！ ");
		// 产生两个实例化对象
		Person p1 = new Person("小明", 25);
		Person p2 = new Person("小红", 23);
		System.out.println("修改之前信息： " + p1.talk());
		System.out.println("修改之前信息： " + p2.talk());
		System.out.println(" **************修改之后信息**************");
		// 修改后的信息
		Person.setCity("上海");// 静态方法可以用类名直接调用
		System.out.println("修改之后信息： " + p1.talk());
		System.out.println("修改之后信息： " + p2.talk());
	}
}

输出结果为：

3.TestStatic 类的静态代码块被调用！ 
4.程序开始执行！ 
2.Person 类的静态代码块被调用！ 
修改之前信息： 我是：小明，今年：25岁，来自：北京
修改之前信息： 我是：小红，今年：23岁，来自：北京
 **************修改之后信息**************
修改之后信息： 我是：小明，今年：25岁，来自：上海
修改之后信息： 我是：小红，今年：23岁，来自：上海

         由以上程序可以得出，static关键字可以用于修饰变量、方法和代码块。静态变量被所有对象共享。静态方法中不可以使用非静态内容，当函数功能没有访问到对象的特有内容时就可以定义为静态。静态代码块用于给类进行初始化，会先执行。


     6、内部类

         分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。这时就是还有的事物定义成内部类来描述。内部类可以直接访问外部类中的成员。外部类要访问内部类，必须建立内部类的对象。

//内部类总结
class Outer {
	int score = 95;

	// 外部类可以访问内部类中的成员,内部类持有了外部类的引用: 外部类名.this
	void inst() {
		Inner in = new Inner();
		in.display();
	}

	// 内部类在局部位置上只能访问局部中被final修饰的局部变量。
	void inst1(final int s) {
		final int temp = 20;
		class Inner1 {
			void show() {
				System.out.println("成绩1：score=" + (score + s + temp));
			}
		}
		Inner1 in = new Inner1();
		in.show();
	}

	// static class Inner{}
	// 用 static 声明的内部类则变成外部类，但是用 static 声明的内部类不能访问非 static 的外部类属性
	public class Inner {
		void display() {
			// 在内部类中声明一name属性
			// String name = "小明";
			System.out.println("成绩: score = " + score);// Outer.this.score
		}

		// static void function(){//如果内部类中定义了静态成员，该内部类也必须是静态的。
		// System.out.println("function run ...."+score); }

	}

	// 在此调用内部类的name属性,会产生错误，外部类不能访问内部类中的属性 public void print(){
	// System.out.println("姓名："+name); }

}

public class InnerClassDemo {
	public static void main(String[] args) {
		Outer out = new Outer();
		out.inst();
		// 直接访问外部类中的内部类中的成员。
		Outer.Inner in = new Outer().new Inner();
		in.display();

		// 如果内部类是静态的。 相当于一个外部类
		// Outer.Inner in = new Outer.Inner();
		// in.display();

		// 如果内部类是静态的，成员是静态的。
		// Outer.Inner.function();
		out.inst1(5);
	}
}

输出结果为：

成绩: score = 95
成绩: score = 95
成绩1：score=120          


二、继  承

     1、继承相关概念

         java中继承用到extends关键字。当类与类之间存在着所属关系（is-a）时，就定义继承。被继承的类成为父类或超类，继承得到的新类成为子类或派生类。父类是子类不断向上抽取出来的。如：class Students（子类） extends Person（父类）。子类会继承父类的所有属性和方法。

         java中不允许多继承，即一个子类不允许有多个父类。但是允许多层继承，即C继承B，B继承A，就出现了继承体系。

    2、子类继承父类的特性

        2.1  子类实例化

一个对象实例化过程：

Person p = new Person();

  • JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类(如果有直接的父类的情况下)；
  • 在堆内存中的开辟空间，分配地址；
  • 并在对象空间中，对对象中的属性进行默认初始化；
  • 调用对应的构造函数进行初始化；
  • 在构造函数中，第一行会先到调用父类中构造函数进行初始化；
  • 父类初始化完毕后，在对子类的属性进行显示初始化；
  • 在进行子类构造函数的特定初始化；
  • 初始化完毕后，将地址值赋值给引用变量。

        2.2  super关键字：用于子类中，调用父类中的构造方法，此时只能放在子类程序的第一行。另外可以通过(super.父类中的属性或方法)来调用父类的内容。但是子类不能访问父类中的私有内容。super关键字与this关键字调用构造函数的操作是不能同时出现的。

        2.3  覆盖

        当子父类中出现成员函数一模一样的情况，会运行子类的函数。这种现象，称为覆盖操作。当对一个类进行子类的扩展时，子类需要保留父类的功能声明，但是要定义子类中该功能的特有内容时，就使用覆盖操作完成。这时函数在子父类中的的两个特性：

  • 重载。同一个类中。overload
  • 覆盖。子类中。覆盖也称为重写，覆写。override
当子类覆盖父类中的内容时，需要注意的是：子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限，并且静态内容只能覆盖静态内容，或被静态内容覆盖。 


//继承总结
class Person {
	String name;
	int age;

	// 父类中构造函数
	public Person() {
		System.out.println("1.public Person(){}");
	}

	// 父类中构造函数
	public Person(String name, int age) {
		// this关键字代表当前对象
		this.name = name;
		this.age = age;
	}

	// 父类中的方法
	public String talk() {
		// this调用本类中的内容
		return "我是： " + this.name + "，今年： " + this.age + "岁 ";
	}
}

// Student类继承于Person类
class Student extends Person {
	String school;

	// 子类中的构造函数
	public Student() {
		// super();隐含super调用父类中的空参数构造函数
		System.out.println("2.public Student(){}");
	}

	public Student(String name, int age, String school) {
		// 分别为属性赋值
		this.name = name;
		this.age = age;
		this.school = school;
	}

	// 此处复写 Person 类中的 talk()方法，并用super调用父类中的talk方法
	public String talk() {
		return super.talk() + "，我在" + this.school + "上学";
	}
}

class ExtendsDemo2 {
	public static void main(String[] args) {
		Student s = new Student();
		Student ss = new Student("小明", 23, "北京");
		// 此时调用的是子类中的 talk()方法
		System.out.println(ss.talk());
	}
}

输出结果为：

1.public Person(){}
2.public Student(){}
1.public Person(){}
我是： 小明，今年： 23岁 ，我在北京上学


三、抽象类

     

    抽象类定义规则

  •  抽象类和抽象方法都必须用 abstract 关键字来修饰。
  •  抽象类不能被实例化，也就是不能用 new 关键字去产生对象。
  •  抽象方法只需声明，而不需实现。
  •  含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

//抽象类
abstract class Person {
	String name;
	int age;
	String occupation;

	//抽象类中定义构造函数
	public Person(String name, int age, String occupation) {
		this.name = name;
		this.age = age;
		this.occupation = occupation;
	}

	// 定义抽象方法 talk()
	public abstract String talk();
}

// Student 类继承自 Person 类
class Student extends Person {
	public Student(String name, int age, String occupation) {
		//调用抽象类中的构造函数
		super(name, age, occupation);
	}

	//覆盖 talk()方法
	public String talk() {
		return "学生的姓名： " + this.name + "，年龄： " + this.age + "，职业："
				+ this.occupation + "！ ";
	}
}

// Worker 类继承自 Person 类
class Worker extends Person {
	public Worker(String name, int age, String occupation) {
		//调用抽象类中的构造函数
		super(name, age, occupation);
	}

	// 覆盖 talk()方法
	public String talk() {
		return "工人的姓名： " + this.name + "，年龄： " + this.age + "，职业："
				+ this.occupation + "！ ";
	}
}

class AbstractDemo {
	public static void main(String[] args) {
		Student s = new Student("小明", 20, "学生");//创建Student对象
		Worker w = new Worker("小强", 28, "工人");//创建Worker对象
		System.out.println(s.talk());//调用的方法
		System.out.println(w.talk());//调用的方法
	}
}


 

 

输出结果为：
 

学生的姓名： 小明，年龄： 20，职业：学生！ 工人的姓名： 小强，年龄： 28，职业：工人！ 
 

 

四、接  口
 

    当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是 接口（ interface）。接口里的数据成员必须初始化，且数据成员均为常量。接口里的方法必须全部声明为 abstract，也就是说，接口不能像抽象类一样有一般方法，而必须全部是“抽象方法”。对于接口当中的成员都有固定的修饰符。全局常量: public  static final ；抽象方法。public abstract。接口是java实现多继承的一种机制，它可以通过多实现来达到多继承的效果。
 

 

//定义接口
interface A {
	int i = 10;//public static final int i = 10;

	public void sayI();//public abstract void sayI();
}

interface E {
	int x = 40;

	public void sayE();
}

// B 同时继承了 A、 E 两个接口
interface B extends A, E {
	int j = 20;

	public void sayJ();
}

// C 继承实现 B 接口，也就意味着要实现 A、 B、 E 三个接口的抽象方法
class C implements B {
	public void sayI() {
		System.out.println("i = " + i);
	}

	public void sayJ() {
		System.out.println("j = " + j);
	}

	public void sayE() {
		System.out.println("e = " + x);
	}
}

class InterfaceDemo {
	public static void main(String[] args) {
		C c = new C();
		c.sayI();
		c.sayJ();
		c.sayE();
	}
}
 

 

 

输出结果为：
 

i = 10
 j = 20
 e = 40
 
 


 
 

五、多  态
 

     一个对象对应着不同类型即为多态。如动物对象里有猫和狗两种形态。在java中多态体现在父类或接口的引用指向其子类对象。多态的存在提高了代码的扩展性，但是使用多态后前期定义的内容不能使用(调用)后期子类的特有内容。多态涉及两个转型：向上转型和向下转型。向上转型会自动完成，向下转型需要进行强制类型转换。
 


 
 

 

//定义多态
abstract class Person {
	abstract void talk();

}

//American类继承Person类
class American extends Person {
	void talk() {
		System.out.println("说英语");
	}

	void playbasketball() {
		System.out.println("打篮球");
	}
}

//Japanese类继承Person类
class Japanese extends Person {
	void talk() {
		System.out.println("说日语");
	}

	void tea() {
		System.out.println("喝茶");
	}
}

class DuoTaiDemo {
	public static void main(String[] args) {

		Person a = new American(); // 向上转型，隐藏子类的特有内容。。

		American c = (American) a;// 向下转型的目的是为了使用子类中的特有方法。
		c.talk();
		c.playbasketball();

		// 对于转型，自始自终都是子类对象在做着类型的变化。
		// Person a1 = new Japanese();
		// Japanese c1 = (Japanese)a1;//ClassCastException
		
		method(new Japanese());

	}

	public static void method(Person p) {
		p.talk();

		// instanceof：用于判断对象的具体类型。只能用于引用数据类型判断,通常在向下转型前用于健壮性的判断。
		if (p instanceof American) {
			American a = (American) p;
			a.playbasketball();
		} else if (p instanceof Japanese) {
			Japanese j = (Japanese) p;
			j.tea();
		} else {

		}

	}
}
 

 输出结果为: 

 

说英语
 打篮球
 说日语
 喝茶
 
 


 
 


 
 


 
 


 
 

 
 ------ 
 Java培训、Android培训 
 、期待与您交流！ ------- 


                

        

        

    

  


    

      

        

            

              
                
                  忧桑的追梦人
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
class构造函数实现接口数据整合

				
			

			

				

					imsopoor的博客
				

				

					09-01
					
					202
					
				

			

		

		

			
				
一般项目接口中很有可能数据分布很不集中，经常出现想要的数据可能在不同对象内。
例如如果要取columns内的数据，以及itemInfo内的部分数据…

按我之前拿数据方法，这样的话就是定义一个对象存放在data内，然后会把columns和itemInfo全部存放在对象内。
今天学习到将所需的数据存入class内，通过带参数的构造函数来实现。
// 将商品基本信息过滤到类中
export class GoodsInfo {
  constructor(itemInfo, columns, services) 

			
		

	



                

              
                



	

		

			

				
					
java接口和抽象类的区别

				
			

			

				

					y_j_y_的博客
				

				

					05-26
					
					265
					
				

			

		

		

			
				
转载于：https://www.cnblogs.com/chenmingjun/p/8811287.html

-----------------------------------------------------------------------------
（1）Java中抽象类和接口中有构造方法吗?

  ①在接口中 不可以有构造方法。
    在接口里写入构造方法时，编译器提示：Interfaces cannot have constructors
  注：
    A...

			
		

	



                


  
              

                


	

		

			

				
					
Java中类、对象、封装、继承和多态(很详细)

				
			

			

				

					weixin_44313771的博客
				

				

					07-02
					
					6063
					
				

			

		

		

			
				
1.类与对象：
（1）类是一种抽象的数据类型，它是对某一类事务的整体描述或定义，但是并不能代表某一具体的事务。例如：人（人有姓名，年龄，性别等特征）；对象是抽象概念的具体事例。例如：赵云就是人（类）的一个具体实例，赵云家的旺财就是狗（类）的一个具体的实例。对象是展现出来的具体实例，而不是抽象的概念。
（2）类与对象的创建：
//这里就是创建了一个Person类
public class Person(){
	//每个类中又包含属性以及方法
	String name;
	int age;
	//方法
	pub

			
		

	





	

		

			

				
					
类的继承中的复写

				
			

			

				

					肖肖的博客
				

				

					11-04
					
					272
					
				

			

		

		

			
				
复写：
如果子类中重复定义了父类中已有的属性，
则称此子类中的属性复写了父类中的属性
格式：
class Super
{
访问权限 方法返回值类型 方法 1（参数 1）
{}
}
class Super extends Super
{
访问权限 方法返回值类型 方法 1（参数 1） 复写父类中的方法
{}
}

...

			
		

	



		

			
		



	

		

			

				
					
黑马程序员——Java面向对象封装继承多态

				
			

			

				

					a951179821的博客
				

				

					07-28
					
					378
					
				

			

		

		

			
				
Java之类的封装，继承，多态

    类的封装

        将对象的状态信息隐藏在对象内部，不允许外部程序直接访问部信息，而是通过该类所提供的方法来实

        现对内部信息的操作和访问。封装是通过设置访问控制符实现的，他们的访问控制如下：








private

default

portected

public 




			
		

	





	

		

			

				
					
黑马程序员——java基础之继承和多态

				
			

			

				

					serge666的博客
				

				

					12-07
					
					273
					
				

			

		

		

			
				
——- android培训、java培训、期待与您交流！ ———-继承：把类中公共的部分抽取出来，做成一个公共的类，让其他类和我们公共的类产生关系，让我们自己的类可以使用公共类。
    这个关系就是继承。
java中也可以有继承，java中的继承指的就是类与类的继承。
    格式：使用extends关键字。
        class 子类 extends 父类{        }被继承的那个类

			
		

	





	

		

			

				
					
黑马程序员——java基础之继承，多态

				
			

			

				

					a1824717的专栏
				

				

					06-29
					
					321
					
				

			

		

		

			
				
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.继承：

提高代码的复用性。让类与类之间产生了关系，才有了多态的特性。
Java语言中：java只支持单继承，不支持多继承。因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是java保留这种机制。并用另一种体现形式来完成表示

			
		

	





	

		

			

				
					
黑马程序员——Java基础——继承与接口

				
			

			

				

					libin1127的博客
				

				

					07-29
					
					419
					
				

			

		

		

			
				
点击打开链接 点击打开链接 点击打开链接 android培训、点击打开链接 点击打开链接 java培训、期待与您交流！">点击打开链接 点击打开链接

			
		

	





	

		

			

				
					
黑马程序员——Java面向对象之继承与多态笔记

				
			

			

				

					bayueqinglian的专栏
				

				

					06-23
					
					476
					
				

			

		

		

			
				
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------


一,继承


继承概述
  多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
那么多个类无需再定义这些属性和行为，只要继承那个类即可。
  通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名 {}  
单独的这个类称为父

			
		

	





	

		

			

				
					
黑马程序员——封装，继承与多态

				
			

			

				

					u013493386的专栏
				

				

					04-03
					
					367
					
				

			

		

		

			
				
---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------


面向对象的三个特征：封装，继承，多态。
封装：
封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。即让对象的属性尽可能的私有，对象的方法尽可能的公开。避免外部对类的破坏。
 
好处：
1.提高安全性，避免不懂的人乱动，以

			
		

	





	

		

			

				
					
黑马程序员——Java面向对象总结

				
			

			

				

					Jiaming84的博客
				

				

					05-27
					
					524
					
				

			

		

		

			
				
------- android培训、java培训、期待与您交流！ ----------

面向对象的概述
1，面向对象是相对面向过程而言的。
2，面向对象和面向过程都是一种思想。
3，面向过程强调的是功能行为。
4，面向对象是将功能封装进对象，强调具备了功能的对象。
5，面向对象是基于面向过程的。

面向对象的三个特征：封装，继承，多态。

类与对象的关系：
    类就是

			
		

	





	

		

			

				
					
黑马程序员——Java要点笔记——面向对象（三）

				
			

			

				

					u013114489的博客
				

				

					07-13
					
					478
					
				

			

		

		

			
				
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

day08 04-面向对象-单例设计模式-概述&体现
1、设计模式：来源与建筑行业。是一种对问题进行有效解决的方式。其实，它是一种思想。
2、单例设计模式（单个实例，单个对象，单块堆内存）
       解决的问题：就是可以保证一个类在内存中的对象唯一性。
3、用全静态也可以实现，

			
		

	





	

		

			

				
					
黑马程序员入学Java知识——精华总结

				
			

			

				

					u014563778的专栏
				

				

					04-17
					
					3589
					
				

			

		

		

			
				
黑马程序员入学Java知识——精华总结
 
J2SE部分，Java高新技术部分，7K面试题部分等黑马入学要求的知识点总结！
 
一、黑马程序员—java概述与基础知识 6
1、何为编程？ 6
2、Java语言概述，历史、特点 6
3、什么是跨平台性？原理是什么？JVM 7
4、Jre和Jdk的区别?
 7
5、java虚拟机JVM
 8
6、 Java程序运行机制 8
7

			
		

	





	

		

			

				
					
黑马程序员——多线程

				
			

			

				

					schwiftX的专栏
				

				

					04-14
					
					596
					
				

			

		

		

			
				
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
         现实生活中很多对象处理的事物都是并发的，比如说一个人可以一边听歌一边看书，脑子里还一边在思考，皮肤感知到痒了还能调动手去挠一挠，这些都是并发完成的。
而计算机就是对现实的模拟，因此也会碰到这种需求，比如说一台个人电脑，内部同时运行着很多的软件，我们打开windows的任务管

			
		

	





	

		

			

				
					
考研复习-英语二真题考试题集-带答案

				
			

			

				

					09-14
				

			

		

		

			
				
英语二考研真题复习资料，带答案版

			
		

	





	

		

			

				
					
2024中美独角兽公司发展分析报告.pdf

				
			

			

				

					09-14
				

			

		

		

			
				
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、

			
		

	





	

		

			

				
					
C++ 中的异步编程模型是什么

				
			

			

				

					09-14
				

			

		

		

			
				
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式：
每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。

在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。

总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。

			
		

	





	

		

			

				
					
正则表达式Regex是一种文本模式.docx

					
最新发布

				
			

			

				

					09-14
				

			

		

		

			
				
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。

基本组成
普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。
特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。
字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。
预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任

			
		

	





	

		

			

				
					
Java继承与super关键字详解：构造函数调用与多态应用

				
			

			

				

					
				

			

		

		

			
				
在Java程序设计中，"super关键字与继承和多态"是一个核心概念，它在第9章中被详细讨论。Java的继承允许子类继承父类的属性和方法，从而实现代码重用和结构化的设计。以下是一些关键知识点：  1. **super关键字的使用...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值