黑马程序员 JAVA-面向对象（二）

最新推荐文章于 2024-11-04 20:33:37 发布

呵呵哒sss

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量373

点赞数

分类专栏：黑马程序员--面对对象文章标签： java 黑马程序员

本文链接：https://blog.csdn.net/zewensong/article/details/42982713

版权

黑马程序员--面对对象专栏收录该内容

3 篇文章 0 订阅

订阅专栏

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

在此，分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正，也希望对想学java的同学有帮助！

JAVA语言-面向对象

面向对象（继承）

继承概述：

1）多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承单独的那个类即可。

2）多个类可以称为子类，单独这个类称为父类或者超类。

3）子类可以直接访问父类中的非私有的属性和行为。

4）通过extends关键字让类与类之间产生继承关系。

class SubDemo extends Demo{ }

5)继承的出现提高了代码的复用性。

6）继承的出现让类与类之间产生了关系，提供了多态的前提。

继承的特点：

1）Java只支持但继承，不支持多继承。

2）Java支持多层继承（继承体系）

3)定义继承需要注意：不要仅为了获取其他类中的某个功能而去继承；类与类之间要有所属（“is a”）关系。XX1是XX2的一种。

super关键字：

1）super和this的用法相同。

2）this代表本类应用。

3）super代表父类应用。

5）当子类出现同名成员时，可以用super进行区分。

6）子类要调用父类构造函数时，可以使用super语句。

函数覆盖（Override）：

1）子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

2）父类中的私有方法不可以被覆盖。

3）在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：
1）覆盖时，子类方法权限一定要大于等于父类方法权限
2）静态只能覆盖静态。

覆盖的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

子类的实例化过程：

1）子类中所有的构造函数默认都会访问父类中空参数的构造函数。

2）因为每一个构造函数的第一行都有一条默认的语句 super()。

3）子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。

4）当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

Java练习代码：

class Tel
{
	void show()//父类show
	{
		System.out.println("number");
	  
	}
}
class NewTel extends Tel //通过extends关键字，产生继承关系
{
	void show()//子类show
	{
                super.show();//super表示父类应用
		System.out.println("picture");
		System.out.println("name");	  
	}
}


class TelDemo
{
	public static void main(String[] args) 
	{
		NewTel t = new NewTel();//实例化对象
		t.show();//调用show方法
	}
}

final关键字：

1）final可以修饰类，方法，变量。

2）final修饰的类不可以被继承。

3）inal修饰的方法不可以被覆盖。

4）final修饰的变量是一个常量。只能被赋值一次。既可以修饰成员变量，又可以修饰局部变量。

(修饰变量)final double PI = 3.14;

5）内部类只能访问被final修饰的局部变量。

抽象类概述：

抽象类的定义：抽象就是从多个事物中将共性的，本质的内容抽取出来。

抽象类：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

抽象类的特点：

1）抽象类和抽象方法必须用abstract关键字来修饰。

2）抽象方法只有方法声明，没有方法体，定义在抽象类中。

3）抽象类不可以被实例化，也就是不可以用new创建对象。

4）抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

Java练习代码：

abstract class Student  //学生抽象类
{
	abstract void study();
}

class BaseStudent extends Student   //基础学生
{
	void study()
	{
	   System.out.println("base study");	  
	}
}
class AdvStudent extends Student  //就业学生
{
	void study()
	{
	   System.out.println("adv study");	  
	}
}
class  AbstractDemo
{
	public static void main(String[] args) //main函数
	{
		new BaseStudent().study();
	}
}

抽象类相关问题：

1）抽象类中是否有构造函数？

答：抽象类中的构造方法用于子类实例化使用。

2）抽象关键字abstract不可以和哪些关键字共存？

答：1).private :因为一个abstract方法需要被重写，所以不能修饰为private;
2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的，所以不能同final共存；
3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间，所以不能同static共存；

3）抽象类中可不可以没有抽象方法？

答：抽象类不能被实例化，用abstract修饰，可以有抽象方法，也可以没有抽象方法，但是有抽象方法的类一定是抽象类。

模板方法：

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。

Java练习代码：

<span style="font-size:18px;">/*
 需求：获取程序运行时间；

 获取系统时间：System.currentTimeMillis();
*/
abstract class GetTime
{
	public final void getTime()//final关键字：强制避免子类重写该函数。
	{
	    long start = System.currentTimeMillis();//开始时间

		runcode();

		long end = System.currentTimeMillis();//结束时间
	
	    System.out.println("用时："+(end-start)+"毫秒");
	}

	public abstract void runcode();//抽象方法
}

class subTime extends GetTime
{
	public void runcode()//重写抽象方法
	{
	    for(int x =1; x<=1000; x++)
		{
		   System.out.print(x);
		}
		System.out.println("运行结束");
	}
}
class TemplateDemo 
{
	public static void main(String[] args) //main函数
	{
		subTime gt = new subTime();
		gt.getTime();
	}
}</span>

未完待续。。。。。

接口：

格式：interface { }

接口中的成员修饰符是固定的。

1) 成员常量：public static final

2)成员函数：public abstract

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口的特点:

1)接口是对外暴露的规则。

2)接口是程序的功能扩展。

3)接口可以用来多实现。

4)类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

5)接口与接口之间可以有继承关系。

Java练习代码：

<span style="font-size:18px;">abstract class Sporter//抽象类
{
   abstract void play();//抽象方法
}

interface Study//接口
{
	abstract void study();//抽象方法
}
class zhangsan extends Sporter implements Study//继承Sporter类，并实现了study方法
{
	public  void play()//重写play
	{
	  System.out.println("play football");
	}
        public  void study()//重写study
	{
	  System.out.println("study Java");
	}

}
class  InterfaceDemo
{
	public static void main(String[] args) //main函数
	{
		zhangsan zs = new zhangsan();
		zs.play();
		zs.study();     
	}
}
</span>

面向对象（多态）

定义：某一类事物的多种存在形态。

例子：动物中猫，狗；

猫这个对象对应的类型是猫类型；

猫x = new 猫();

同事猫也是动物中的一种，也可以把猫称为动物。

动物 y = new 猫();

动物是猫和狗具体事物中抽取来的父类型。

父类型引用指向了子类对象。

多态的体现：父类的引用指向了自己的子类对象；父类的引用也可以接收自己的子类对象。

多态的前提：必须是类与类之间有体系，继承或者实现。通常还有一个前提：存在覆盖。

多态的好处：多态的出现大大的提高了程序的扩展性。

多态的弊处：提高了扩展性，但是只能使用父类的引用访问父类中的成员。

多态的特点：编译时：参阅引用型变量所属的类中是否有调用方法。如果有，编译通过，没有编译失败；
运行时：参阅对象所属的类中是否有调用的方法。
简单总结：成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）。
在多态中，静态成员函数在多态调用时，无论编译和运行，都参考左边。

Java练习代码：

<span style="font-size:18px;">class Fu//父类
{
	void method_1()
	{
		System.out.println("fu method_1");	
	}
	void method_2()
	{
		System.out.println("fu method_2");	
	}
}

class Zi extends Fu//子类继承父类，并重写了其方法
{
	void method_1()
	{
		System.out.println("Zi method_1");	
	}
	void method_3()
	{
		System.out.println("Zi method_3");	
	}
}

class DuotaiDemo2 
{
	public static void main(String[] args) 
	{
		Fu f = new Zi();//多态
		f.method_1();//结果：Zi method_1。Zi类中有该方法，运行时执行Zi类中对象。
		f.method_2();//结果：Fu method_2.
		//f.method_3();//Zi类中没有该方法编译不通过，

	}
}
</span>

Java练习代码：

<span style="font-size:18px;">abstract class Animal//定义一个Animal类
{
	public abstract void eat();
}

class Cat extends Animal//cat类继承Animal类
{
	public void eat()//重写了Animal类的eat方法
	{
		System.out.println("吃鱼");	
	}

	public void catchMouse()//cat类的方法
	{
		System.out.println("抓老鼠");	
	}
}
class Dog extends Animal</span><span style="font-size: 18px; font-family: Arial, Helvetica, sans-serif;">//Dog类继承Animal类</span><span style="font-size:18px;">

{
	public void eat()//重写了Animal的eat方法
	{
		System.out.println("吃骨头");	
	}

	public void kanJia()//自己的方法
	{
		System.out.println("看家");	
	}
}
class  duoTaiDemo
{
	public static void main(String[] args) 
	{
		//Animal a = new Cat();//类型提升，向上转型。
		//a.eat();
		funcation(new Cat());

		funcation(new Dog());
	
	}
	public static void funcation(Animal a)
	{
		a.eat();
		if (a instanceof Cat) //instanceof:用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
		{
			Cat c= (Cat) a;//调用猫的特有方法时，强制将父类的引用，转成子类类型，向下转型。
		    c.catchMouse();
		}else if (a instanceof Dog)
		{
			Dog d= (Dog) a;//调用猫的特有方法时，强制将父类的引用，转成子类类型，向下转型。
		    d.kanJia();
		}
		
	}
}
</span>

内部类

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

访问特点：

1）内部类可以直接访问外部类中的成员，包括私有成员。

2）而外部类要访问内部类中的成员必须要建立内部类的对象。

访问格式：
1、当内部类定义在外部类的成员位置上，而且是非私有，可以在外部其他类中
可以直接建立内部对象。
外部类名.内部类名变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
2、当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private ：将内部类在外部类中进行封装。
static：内部类具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。
在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().method();
在外部其他类中，如何直接访问static内部类的静态成员？
Outer.Inner.method();
注意：当内部类中定义了静态成员，该内部类必须是static。
当外部类中的静态方法访问内部类时，内部类也必须是static。

Java练习代码：

<span style="font-size:18px;">class Outer//定义一个外部类
{
	static int num = 4;
	static class Inner //定义一个内部类
	{
		//int n = 6;
		void method()
		{
		    System.out.println("Inner="+num);
		}
	}


}
class  InnerclassDemo 
{
	public static void main(String[] args) 
	{
		//Outer.Inner in = new Outer().new Inner();
		//in.method();
		  new Outer.Inner().method();//当内部类被static修饰后，只能直接访问外部类中的static成员。
		//Outer.Inner.method();
	}
}
</span>

内部类的位置：

1)内部类定义在成员位置上:可以被private static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

2)内部类定义在局部位置上:也可以直接访问外部类中的成员。同时可以访问所在局部中的局部变量，但必须是被final修饰的。

Java练习代码：

<span style="font-size:18px;">class Outer
{
	int x = 3;

	void method(final int a)
	{
		//内部类定义在局部时：1、可以直接访问外部类中的成员，但是不可以访问它所在的局部，只能访问被final修饰的变量。
		int y = 4;
		class Inner//2、局部内部类不能被private和static修饰
		{
			void function()
			{
			    System.out.println(a);//要想访问y，需定义为final int y = 4；
			}
		}
		new Inner().function();	
	}
}
class  InnerclassDemo2
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.method(7);//进栈后赋给a后，释放。
		out.method(8);//进栈后赋给a后，释放。
	}
}</span>

匿名内部类：

定义：就是内部类的简化写法。

前提：内部类可以继承或实现一个外部类或者接口。

格式为：new 外部类名或者接口名(){

覆盖类或者接口中的代码，

(也可以自定义内容。 )

}

简单的理解：就是建立一个建立一个带内容的外部类或者接口的子类匿名对象。

Java练习代码：

<span style="font-size:18px;">abstract class absDemo
{
	abstract void show();//抽象方法show
}
class Outer
{
	int x = 3;
	/*
	class Inner extends absDemo//内部类
	{
		void show()
		{
		   System.out.println("show:"+x);
		}
	}
	*/
	public void function()
	{
	   //absDemo a =new Inner();
	   //new Inner().show();
	   //匿名内部类
	   absDemo a = new absDemo()
	   {
		   void show()
		   {
		      System.out.println("show="+x);
		   }
		   void haha()
		   {
		      System.out.println("haha");
		   }</span>