黑马程序员--java基础复习之多态与Object及匿名内部类

最新推荐文章于 2022-04-21 16:35:02 发布
最新推荐文章于 2022-04-21 16:35:02 发布
阅读量601 收藏 1
点赞数
分类专栏： java基础学习 文章标签： 多态 Object 匿名内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/menghanshi/article/details/44465859
版权
------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------



多态

定义：某一类事物的多种存在形态
例如：动物中的猫、狗。猫这个对象对应的类型是猫类型，如：猫 x = new猫(); 同时猫也是动物中的一种，也可以把猫称为动物。
动物  y = new 猫(); 那么动物就是猫和狗具体事物中抽取出来的父类型。父类型引用指向了子类对象。

多态：可以理解为事物存在的多种体现形态
1、多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
2、多态的前提
必须是类与类之间有关系。要么继承，多么实现
通常还有一个前提：存在覆盖
3、多态的好处
多态的出现大大的提高程序的扩展性
4、多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员
如下代码： 
abstract class Animal
{
	abstract void eat();  //定义一个eat()的抽象方法，所以这个类也是一个抽象类
	//其子类调用此类的时候，要对其抽象方法全部重写
}

interface Catch
{
	abstract void catchMou();
}

//继承动物这个类
class Cat extends Animal  implements Catch   
{
	void eat()
	{
		System.out.println("我是猫，我吃鱼");
	}	
	public void catchMou() //重写(覆盖)接口中的抽象类
	{
	  System.out.println("接口：抓老鼠抓老鼠抓老鼠抓老鼠");	
	}
	
	void CatchMouse()  //子类的独有方法
	{
		System.out.println("我是猫，这是我的独有功能：抓老鼠");
	}
}

class Dog extends Animal  //继承动物这个类
{
	void eat() //重写eat()这个方法
	{
		System.out.println("我是狗，吃骨头");
	}
	void kanJia()  //Dog类的独有方法
	{
		System.out.println("我是狗，这是我的独有功能：看家");
	}
}

class Pig extends Animal  //继承动物这个类
{
	void eat()
	{
		System.out.println("我是猪，吃饲料");
	}
	void GongDi()
	{
		System.out.println("我是猪，这是我的独有功能：拱地");
	}
}


class DuoTaiDemo
{
	 public static void main(String[] args)
	 {
		 System.out.println("*****************使用多态前******************");
		 /*****************前期做法******************/
		 function(new Cat());  //调用猫的eat()方法
		 function(new Dog());  //调用狗的eat()方法
		 function(new Pig());  //调用猪的eat()方法
		 /*******************************************/
		 System.out.println("*****************使用多态******************");
		 /*****************使用多态******************/
		 functionDuoTai(new Cat());
		 functionDuoTai(new Dog());
		 functionDuoTai(new Pig());
		 /*******************************************/
		 
		
		 /*******************************************/
		 
	 }
	 
	 /*****************前期做法******************/
	 //以下为以往做法，代码重复冗余
	 public static  void function(Cat c)
	 {
		 c.eat();	
		c.catchMou();
	 }
	 public static  void function(Dog d)
	 {
		 d.eat();		 
	 }
	 public static  void function(Pig p)
	 {
		 p.eat();		 
	 }
	 /*******************************************/
	 
	 /*****************使用多态******************/
	 public static void functionDuoTai(Animal a)
	 {
		
		 
		 //运行动物的独有功能
		 //多态的类型转换
		
		 if
		 (a instanceof Cat)  //如果Animal是猫
		 {
			 Cat c=(Cat)a;  //将动物向下转换成猫
			 c.CatchMouse(); //猫的特有功能
		 }
		 else if(a instanceof Dog)
		 {
			 Dog d=(Dog)a; //将动物向下转换成狗
			 d.kanJia();
		 }
		 else if(a instanceof Pig)
		 {
			 Pig p=(Pig)a;
			 p.GongDi();
		 }
		 
	 }
	/*******************************************/
 }
结果：

 这代码就是多态的体现，假设子类Cat中有特有的抓老鼠功能，父类型的 a就不能直接调用。这上面的代码中，可以理解为Cat类型提升了，向上转型。如： 
	Animal a=new Cat();//类型提升，向上转型
	//如果想要调用猫的特有方法时，得强制将父类的引用，转成子类类型		
	Cat c=(Cat)a;
        如果此时父类的引用想要调用Cat中特有的方法，就需要强制将父类的引用，转成子类类型，向下转型。如：Catc = (Cat)a;
注：如果父类可以创建对象，如：Animal a = new Animal(); 此时，就不能向下转型了，Cat c = (Cat)a; 这样的代码就变得不容许，编译时会报错。所以千万不能出现这样的操作，就是将父类对象转成子类类型。
        我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态至始至终都是子类对象在做着变化。

看一个例子： 
/*
基础班学生：学习，睡觉
高级班学生：学习，睡觉
可以将这两类事物进行抽取
*/
abstract class Student
{
	//定义一个抽象方法
   public abstract	void study();
   
   //这个方法可以继承(子类对象可以直接使用)，也可以复写
   void sleep()
   {
	   System.out.println("躺着睡");
   }
}

//基础班学生
class BaseStudent extends Student
{
	//复写父类的study方法
	public void study()
	{
		System.out.println("基础学习");
	}
	//复写父类的sleep方法
	void sleep()
	{
		System.out.println("坐着睡");
	}
}
class AdvStudent extends Student
{
	//复写父类的study方法
	public void study()
	{
		System.out.println("高级学习");
	}
}

class DoStudent
{
	//多态的使用
	 void DoSome(Student s)
	{
		s.study();
		s.sleep();
	}
}

class DuoTaiDemo
{
	public static void main(String[] args)
	{
		DoStudent ds=new DoStudent();
		
		ds.DoSome(new BaseStudent());
		ds.DoSome(new AdvStudent());
	}	
}
上述代码是定义了一个中间的类，将基础班学生和高级班学生的共同行为封装在一个类中，使用其父类作为参数传递，也是用到了多态。
下面也是一个多态的小应用，其分为三个部分

1、定义好工具类，即将共同行为封装在一个类中。

2、对类型进行抽取，---->多态的产生。

3、操作同一父类型，对其中的子类型均可操作


如下： 
/*
多态的应用

需求：
电脑运行实例，电脑运行是基本于主板的。
假设主板只是提供电脑运行，但是没有上网，听歌等功能。
而上网、听歌需要硬件的支持。而现在主板上没有网卡和声卡，这时可以定义一个规则，叫PCI，
只要符合这个规则的网卡和声卡都可以在主板上使用，这样就降低了主板和网卡、声卡之间的耦合性。
用程序体现。
*/

//创建一个主板类
class MainBoard
{
	public void run()
	{
		System.out.println("主板运行");
	}
	
	public void usePCI(PCI p)  //PCI p=new NetCard();接口型引用指向自己的子类对象
	{
		if(p!=null)  //当使用设备时
		{
			p.open();
			p.close();
		}			
		
	}
}

//创建一个接口 PCI
interface PCI
{
	void open();
	void close();
}

//网卡实现PCI接口
class NetCard implements PCI
{
	public void open()
	{
		System.out.println("网卡运行");
	}
	public void close()
	{
		System.out.println("网卡停止");
	}
}

//声卡实现PCI接口
class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("声卡运行");
	}
	public void close()
	{
		System.out.println("声卡停止");
	}
}

class DuoTaiDemo5
{
	public static void main(String[] args)
	{
		//运行主板
		MainBoard mb=new MainBoard();
		mb.run();
		//主板通过PCI接口操作设备
		mb.usePCI(null);
		mb.usePCI(new SoundCard());
		mb.usePCI(new NetCard());
	}
}

1、在多态中成员函数(非静态)的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

如下：

class Fu
{
	void method1()
	{
		System.out.println("Fu Method1");
	}
	void method2()
	{
		System.out.println("Fu Method2");
	}
}

class Zi extends Fu
{
	void method1()
	{
		System.out.println("Zi Method1");
	}
	void method3()
	{
		System.out.println("Zi Method2");
	}
}

class DuoTaiDemo3
{
		public static void main(String[] args)
		{
			Fu z=new Zi();
			z.method1();
			z.method2();
			//z.method3();  //编译失败
		}
}
结果：

简单总结：成员函数在多态调用时，编译看左边，运行看右边


2、在多态中成员变量的特点：无论编译或运行，都参考左边(引用型变量所属的类)

如下面代码:

class Fu
{
	int num=5;
}

class Zi extends Fu
{
	int num=8;
}

class DuoTaiDemo4
{
		public static void main(String[] args)
		{
			Fu f=new Zi();
			System.out.println(f.num);
			Zi z=new Zi();
			System.out.println(z.num);
		}
}
运行结果：



3、在多态中，静态成员函数的特点（在开发中很少见，因为很少会去复写静态方法）
无论编译和运行，都参考左边    如下： 
class Fu
{
	int num=5;
	static void method()
	{
		System.out.println("Fu  method");
	}
}

class Zi extends Fu
{
	int num=8;
	static void method()
	{
		System.out.println("Zi  method");
	}
}

class DuoTaiDemo4
{
		public static void main(String[] args)
		{
			Fu f=new Zi();			
			f.method();
			Zi z=new Zi();			
			z.method();			
		}
}
结果：









Object类

类Object是类层次结构的根类。每个类都使用Object作为超
类。
Object ：是所有对象的直接或者间接父类，传说中的上帝
该类中定义的肯定是所有对象都具备的功能。

下面讲的就是Object中的常用的方法

equals  
boolean equals(Object obj)           指示其他某个对象是否与此对象“相等”。(其实比较的就是对象在内存中的地址值)
参数类型是Object ，这里也是用到了多态。

如下代码： 
class Demo
{
	
}	
	 
class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo  d1=new Demo();
		Demo d2=new Demo();
		Demo d3=d1;
		
		System.out.println(d1.equals(d2));  //d1和 d2分别指向不同的对象，地址值自然不同 false
		System.out.println(d1==d2);  //在比较对象时，==和equals 效果一样  false
		
		System.out.println(d1.equals(d3)); //d1和d3均指向同一个对象，所以地址值自然一样  true
		System.out.println(d1==d3);  //同上
		
	}
}
结果：





Object类中已经提供了对对象是否相同的比较方法。
如果自定义类中也有比较相同的功能，没有必要重新定义，只要沿袭父类Object中的功能，建立自己特有的比较内容即可。这就是覆
盖。如下： 

class Demo
{
	private int num;
	Demo(int num)
	{
		this.num=num;
	}
	//复写父类Object中的equals方法
	public boolean equals(Object obj)
	{
		if(obj instanceof Demo) //判断是否是Demo类型的对象
		{
			Demo d=(Demo)obj;
			return this.num==d.num;
		}
		return false;
	}
}	
	 
class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo  d1=new Demo(5);
		Demo d2=new Demo(5);
		
		System.out.println(d1.equals(d2));
	}
}

结果：


内部类

内部类：将一个类定义在另一个类的里面，对里面那个类就称为内部类(内置类，嵌套类)

访问特点：
A、内部类可以直接访问外部类中的成员，包括私有成员
之所以可以直接访问外部类中的成员，是因为外部类中持有了一个外部内的引用，格式 外部类名.this
B、而外部类要访问内部类中的成员必须要建立内部类的对象

如下代码： 
//外部类
class Outer
{
	private int x=3;
	
	//内部类
	class Inner
	{
		void function()
		{
			//访问外部类中的成员，包括私有成员
			System.out.println("Inner:"+x);
		}
	}
	
	void method()
	{
		//外部类要访问内部类中的成员必须要建立内部类的对象
		Inner in=new Inner();
		in.function();
	}
}

class InnerClassDemo
{
	public static void main(String[] args)
	{
		Outer ou=new Outer();
		ou.method();
		
		/*********在其他类中直接访问内部类中的成员************/
		//当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象。
		Outer.Inner in=new Outer().new Inner();		
		in.function();
	}
}

再看下面一段代码： 
class Outer
{
	private int x=3;
	private int y=6;
	class Inner
	{
		int x=4;
		void function()
		{
			int x=5;
			System.out.println("Inner:"+x); //访问本类中的局部变量x
			System.out.println("Inner:"+this.x);  //访问本类中的x，所以用this
			System.out.println("Inner:"+Outer.this.x);//访问外部类中的本类变量x，所以加上Outer.this
			System.out.println("Inner:"+y); //这里因为没有同名变量，所以省略了Outer.this
		}
	}
	
	void method()
	{
		Inner in=new Inner();
		in.function();
	}
}

class InnerClassDemo0
{
	public static void main(String[] args)
	{
		Outer ou=new Outer();
		ou.method();			
	}
}

结果：
从上述代码中可以得出：之所以可以直接访问外部类中的成员，是因为外部类中持有了一个外部内的引用，格式 外部类名.this

从上面的代码中可以看到内部类的访问格式
访问格式：
1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象。
格式：外部类名.内部类名  变量名=外部类对象.内部类对象
                                           如 Outer.Inner  in=new Outer().new Inner();
2、当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装


静态内部类
 static:内部类就具备static 的特性。
当内部类被static 修饰后，只能直接访问外部类中的static成员。出现了访问局限。

如下代码片段： 
class Outer
{
	 private int x=3;
	
	//静态内部类
	static class Inner
	{
		void function()
		{
			System.out.println("Inner:"+x);
		}
	}
}
结果：

因为内部类用static修饰后，就具备了static的特性。所以静态不能直接访问非静态

注意：当内部类中定义了静态成员，该内部类必须是静态的n
 当外部类中的静态方法访问内部类时，内部类也必须是static的

如下代码段： 
class Outer
{
	 private int x=3;
	
	//静态内部类（当内部类中有静态成员时，该内部类必须是静态的）
	static class Inner
	{
	  static void function()
		{
			System.out.println("Inner:"+x);
		}
	}
}


3、内部类定义在局部时：

1、不可以被成员修饰符修饰(static  private)
2、可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量

用如下代码说明： 
<span style="color:#666666;">class Outer
{
	int x=3;
	void method()
	{
		final int y=4;
		//局部内部类
		class Inner
		{			
			void function()
			{
				System.out.println("局部内部类："+x);
				//如果y没有用final修饰，则访问y时编译器会提示：从内部类中访问局部变量y；
				//需要被声明为最终类型
				System.out.println(y);
			}
		}
		
		//要想访问非静态，必须通过对象
		
		new Inner().function();
	}
}

class InnerClassDemo1
{
	public static void main(String[] args)
	{
		new Outer().method();
	}
}</span>






匿名内部类

1、匿名内部类其实就是内部类的简写格式。
2、定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
3、匿名内部类的格式：new 父类或者接口(){定义子类的内容}
4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。
5、匿名内部类中定义的方法最好不要等于或超过3个

用一个例子来说明： 
//定义一个抽象类，作为匿名内部类的父类
abstract class AbsDemo
{
	abstract void show();
}

//外部类
class Outer
{
	int x=8;
	void method()
	{
		//new Inner().function();
		/**********使用匿名内部类1***********/
	
		new AbsDemo()
		{
			//复写父类的抽象方法
			void show()
			{
				System.out.println("我是匿名内部类："+x);
			}
		}.show();
		/**********使用匿名内部类2***********/
		new AbsDemo()
		{
			//复写父类的抽象方法
			void show()
			{
				System.out.println("我是匿名内部类："+x);
			}
			void haha()
			{
				System.out.println("haha");
			}
		}.haha();
		
		/**********使用匿名内部类2***********/
		
		//这个是加载中的向上提升
	AbsDemo ad=	new AbsDemo()
		{
			//复写父类的抽象方法
			void show()
			{
				System.out.println("我是匿名内部类："+x);
			}
			//这个方法其实没什么意义
			void haha()
			{
				System.out.println("haha");
			}
		};
		
		ad.show();
		//ad.haha();//这句会编译失败，因为父类中根本没有haha这个方法
	}
	
	
}

class InnerClassDemo3
{
	public static void main(String[] args)
	{
		new Outer().method();
	}
}

下面来看一个匿名内部类的题目： 

interface Inter
{
	void method();
}
class Test
{
	//补足代码。通过匿名内部类
}

class InnerClassTest
{
	public static void main(String[] args)
	{
		Test.function().method();
	}
}
代码及思路如下： 
//这个接口是作为内部类的父类存在的(注：接口中全部都是public 类型的抽象方法)
interface Inter
{
	void method();
}
class Test
{
	//补足代码。通过匿名内部类
	static Inter function()
	{
		return new Inter()
		{
			public void method()
			{
				System.out.println("这是一个匿名内部类的小题目");
			}
		};
	}
}

class InnerClassTest
{
	public static void main(String[] args)
	{
		Test.function().method();
		//思路：
		//Test.function():Test类中有一个静态的方法 function.
		//.method()：function这个方法运算后的结果是一个对象。
		//因为只有是Inter类型的对象，才可以调用method方法。
	}
}

再看另一个匿名内部类的题目： 
/*补全下面的代码，想使用一个function方法。要求使用匿名内部类的方式完成*/

class InnerTest
{
	public static void main(String[] args)
	{
		//补足代码。通过匿名内部类
	}
}

完成:因为没有定义父类或接口，所以想到Object是所有类的直接或间接父类。 
class InnerTest
{
	public static void main(String[] args)
	{
		//补足代码。通过匿名内部类
		new Object()
		{
			void function()
			{
				System.out.println("Hello world");
			}
		}.function();
	}
}
















关山明月
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员 - Java基础教学 - 08 - 面向对象（4）-多态.doc
04-21
黑马程序员 - Java基础教学 - 08 - 面向对象（4）-多态.doc
javase第十四天：面向对象总结（内存解析，多态的理解，匿名对象，Object类的使用，包装类的使用，单例模式，接口和抽象类的区别）
qq_44724899的博客
09-22 62
学习
多线程（二）
m0_58006481的博客
04-21 691
一.线程共享的内存区域：堆（对象实例）、方法区（被加载的类）、常量池，私有区域：PC，栈（局部变量） 二.线程不安全出现原因；CPU缓存和内存的关系 三.保护线程安全的机制：锁（synchronized修饰符、互斥、加锁粒度，sync保原子性、内存可见性、重排序约束）；JUC包下类和对象形式给我们使用锁；状态转移图（全）；Volatile机制；单例模式
Java面試題6（hibernate+aop）
t15263857960的博客
03-08 342
1.MyBatis中#和$的区别： 1)#和$都可以充当占位符， #的底层是通过PreparedStament实现的，$的底层是通过Stament实现的 2)只有传入数据库对象时才会使用到$ 2.1按照某个表进行查询时输入表名 2.2按照表中的某一列进行排序时，输入类名 3)在传入非数据使用库对象时最好不要使用$ 4）#是先编译sql语...
synchronized方法的安全问题
chunconghui7899的博客
12-21 539
1常见问题 synchronized方法是一种常用的线程同步方法，在我们代码中多处使用。但是使用不当的情况下容易引入安全问题，因此《Java编码安全Checklist_V2.0》中专门设置了一个检查项： 与非信任代码交互的类的同步操作要使用私有的、无法被非信任代码访问与修改的...
黑马程序员_学习笔记：5) 面向对象3：多态、Object、内部类、匿名内部类
awangk2的专栏
04-28 344
多 态★★★★★（面向对象特征之一）：函数本身就具备多态性，某一种事物有不同的具体的体现。   体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat(); 多态的好处：提高了程序的扩展性。 多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)
Java多态及Java内部类
08-03
Java多态，Java内部类
java程序设计-第5章-继承、多态、重载与接口
03-12
java程序设计_第5章_继承、多态、重载与接口
Java零基础-多态.md
最新发布
08-10
内容概要： 本文介绍了Java中多态...建议通过阅读相关的Java教材或搜索资料，进一步了解与多态相关的高级主题，如抽象类和接口等内容。 如有疑问，可以参考Java官方文档或向技术论坛寻求帮助，进一步加深对多态的理解。
轻松学Java之继承与多态优秀PPT.pptx
11-30
轻松学Java之继承与多态优秀PPT.pptx
题目-java基础
weixin_42547039的博客
10-26 404
多线程和单线程 线程不是越多越好，假如你的业务逻辑全部是计算型的（CPU密集型）,不涉及到IO，并且只有一个核心。那肯定一个线程最好，多一个线程就多一点线程切换的计算，CPU不能完完全全的把计算能力放在业务计算上面，线程越多就会造成CPU利用率（用在业务计算的时间/总的时间）下降。但是在WEB场景下，业务并不是CPU密集型任务，而是IO密集型的任务，一个线程是不合适，如果一个线程在等待数据时，把CPU的计算能力交给其他线程，这样也能充分的利用CPU资源。但是线程数量也要有个限度，一般线程数有一个公式：最佳启
黑马程序员--java基础之交通灯管理系统(7K面试题)
menghanshi的专栏
04-22 1236
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 说点废话，一般看题目之前，我都会在心里提前琢磨一下，要用到什么知识，大体思路是什么。看到这个7K面试题，光看题目的话，交通灯管理系统，心里就一阵发怵，为啥，因为我对这个红绿灯仅有的知识大概就是红灯停，绿灯行，黄灯亮了等一等，以及，红灯--->绿灯---->黄灯--->红灯 这些
java学习过程中的异常处理方式
menghanshi的专栏
01-29 774
这两天在学习java基础中的异常，可能是以前在学校的时候没弄清楚，而且参加工作了以后在asp.net的开发中也很少用到，所以这两天学习java基础的过程中，感觉有些困难，所以在这里记录总结一下 首先，异常的概念 异常：程序在运行时出现的不正常情况 由来：这种问题也是现实生活中一个具体的事物，可以通过java的类的形式进行描述，并封装成对象，其实就是java对不正常情况进行描述后的对象体现，即
黑马程序员--java基础复习之网络编程
menghanshi的专栏
04-12 736
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------        还记得以前在学校的时候，学习网络编程，用UDP写个聊天室，然后在教室里通过局域网接收同学们的消息，然后也向其他人发送消息，玩得不亦乐乎。如今，再次拾起旧日情怀，重新学习网络编程的知识，只是时光变迁，已是七年之后的事了，那时是学的C#，而现在却是Java，那时正值青春年少，
黑马程序员--java基础复习之多线程及线程间通信
menghanshi的专栏
03-22 636
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 进程： 进程：是一个正在执行的程序 每个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元 线程： 线程就是进程中的一个独立的控制单元，线程在控制着进程的执行。一个进程中至少有一个线程。 多线程：  在java虚拟机启动的时候会有一个java
黑马程序员--java基础复习集合框架工具类及其他对象
menghanshi的专栏
03-30 565
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------     前面一章，讲到了集合，这里大略回忆下，最上级Collection接口下的基本方法，如add()，remove()，equals(),contains(),hashCode(),isEmpty()，iterator()等基本方法，即其下面的子接口或实现类都能使用或复写的功能。接着
黑马程序员--java基础之正则表达式
menghanshi的专栏
04-16 548
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 以前在公司上班的时候，因为工作上的需要，同事写了一个在网页上抓取数据的程序，然后放在公司的服务器，不停的运行，然后从别人的网站上抓取我们需要的数据，每隔3秒就访问一次网页，然后从新的网页上抓取数据。当时感觉很牛B，毕竟叫我弄，我是搞不定的，因为我不懂正则表达式。如今，咱也学习正则表达了
黑马程序员--java基础复习之数组
menghanshi的专栏
03-16 488
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------    在刚开始学习数据类型的时候，我们就学习过了八种基本数据类型   byte   short   int   lang  float    double  char  boolean  ，还有就是三种引用类型，第一个就是数组，以及类和接口。    首先，是数组的定义，数组是同一类型
学习-java继承和多态之abstract类
03-16
在 Java 中，abstract 类是一种特殊的类，它不能被实例化。它可以包含抽象方法，这些方法必须在子类中被实现。抽象类可以被用来定义接口或者实现一些公共功能。通过继承抽象类，子类可以继承抽象类中的所有非抽象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值