黑马程序员——接口、多态、构造函数_接口为什么不能有构造函数?-黑马程序员技术交流社区 - 手机版

本文链接：https://blog.csdn.net/fuxiaoyuqing/article/details/39161679

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

兴趣是学习编程最好的老师

不积跬步，无以至千里

这辈子没办法做太多事情，所以每一件都要做到精彩绝伦。

<接口(interface)>

1.接口是当一个类中所有的方法都是抽象的时候，就可以定义为接口。接口解决了java中只能单继承的局限，因为虽然类与类之间只能是单继承，但是接口与接口之间可以是单继承，也可以是多继承。类与接口可以是单实现，也可以是多实现。

作为功能扩展：
在Java中不允许多继承，但允许同时实现多个接口,例如;
	interface IA{
		void f1();
		void f2();
	}
	interface IB{
		void f2();
		void f3();
	}
	class A implements IA,IB{
	}

2.成员特点：

A：只有成员变量和成员方法。

B：成员变量默认修饰符 public static final

int i = 20；会被默认为public static final int i = 20;

C：成员方法默认修饰符 public abstract

void show()；会被默认为public abstract void show();

例如：
interface IPersonnel
{
	int num  = 2;                 //默认为public static final int num = 2;
	void say();                    //默认为public abstract say();
	void show();                   //默认为public abstract show();

}
class Student implements IPersonnel
{
	//访问修饰符一定要等于或大于父类的访问修饰符；
	//访问权限从小到大为：private (默认) protected  public
	public void say(){
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

3.接口特点：

接口符合对外暴露的规则并且实现了功能的扩展，降低了程序的耦合性。高内聚，低耦合。接口的理解，狭义的理解为Java中的接口。广义的理解为任何定义的规范都是接口。

4.接口和抽象类的区别：

1）：抽象类只能被单继承；接口可以被多实现。

2）：抽象类中的成员变量可以是常量，也可以是变量。成员方法可以是抽象的，也可以是非抽象的。构造方法虽然不可以创建对象，但是可以给子类实例化用。

接口中的成员变量只能是常量。默认修饰符 public static final。成员方法只能是抽象的。默认修饰符 public abstract

3）抽象类中定义的是体系结构中的共性的内容。接口中定义的是对象的扩展功能。

4)抽象类被继承表示的是："is a"的关系。a是b中的一种。接口被实现表示的是: "like a"的关系。a像b中的一种。

5.接口、抽象类、接口之间的实现与继承如图：

<多态>

1.某一类事物的多种存在形态。方法重载(静态多态),方法重写(动态多态,对象多态)。对象多态必须满足类与类(或接口)要有继承(或实现)关系。有重写父类或接口的方法，一定要有父类或者接口的引用指向子类的对象。

2.多态中的成员特点：

举例：动物的例子：

向上转型

Animal a = new Cat();

a.eat();

向下转型

Cat c = (Cat)a;

c.eat();

向上转型

Animal a = new Dog();

向下转型转换异常

Dog d = (Dog)a;

多态的特点：

1.当父类的引用指向子类对象时，访问被覆盖成员时，访问的是父类的，在调用被覆盖的方法时，调用的是子类的。方法是运行时动态绑定的；

2.当父类的引用指向子类对象时，不能访问子类自有的成员；只能访问被覆盖的

class Personnel
{
	int num = 10;
	void say(){
		System.out.println("我是传智播客一员");
	}
}
class Student extends Personnel
{
	int num = 20;
	//重写的
	void say(){
		System.out.println("我是一名学生");
	}
	//自有的方法
	void show(){
		System.out.println("子类的show()");
	}
}
class Teacher extends Personnel
{
	//重写
	void say(){
		System.out.println("我是一名教师");
	}
	//自有的方法
	void teach(){
		System.out.println("讲解Java");
	}
}
class Master
{
	void talk(Personnel obj){

		System.out.println(obj.num);
		obj.say();
		 
		if(obj instanceof Student){
			Student stu = (Student)obj;
			stu.show();
		}
		if(obj instanceof Teacher){
			Teacher tea = (Teacher)obj;
			tea.teach();
		}
		
	}
	
}
class  Demo
{
	public static void main(String[] args) 
	{
		Student stu = new Student();
		Teacher tea =new Teacher();

		Personnel p = new Teacher()
		Teacher t = (Teacher)p;

		Master m = new Master();
		m.talk(stu);
	}
}

<构造方法>

1.初始化代码块位于类体中,每当创建此类的对象时，都会执行一次,一般用于初始化数据成员，以及做一些类的初始化工作；

2.构造函数位于类体中,如果存在"初始化代码块"时，是在"初始化代码块"之后执行；

构造函数的规则：跟类名相同,不能有返回值的声明，甚至是void可以重载,如果定义了带参的构造器，那么Java不再自动添加默认构造器；

class Student{
	private String stuName;
	private int stuAge;

	//定义一个默认的，无参的构造函数
	Student(){
	}
	//定义一个带参数的构造函数
	Student(String stuName,int stuAge){
		
		this.stuAge = stuAge;
	}
	
	Student(String stuName){
		this.stuName = stuName;
	}
	Student(int stuAge){
		this.stuAge = stuAge;
	}
	
	
	//初始化代码块
	{
		System.out.println("Student的初始化代码块！");
	}
	void show(){
		System.out.println("我叫：" + stuName + " ,年龄：" + stuAge);
	}


}

3.单例模式

class Student
{
	//2.步骤2
	private static Student stuObj = null;
	//1.步骤1
	private Student(){
	}
	//3.步骤3
	public static Student getStudentInstance(){
		if(stuObj == null){
			System.out.println("构造了一个Student对象");
			stuObj = new Student();
		}
		System.out.println("返回一个Student引用");
		return stuObj;
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		Student stu = Student.getStudentInstance();//第一次获取，产生一个对象

		Student stu2 = Student.getStudentInstance();//之后再获取，将直接返回引用，不再产生对象
		Student stu3 = Student.getStudentInstance();
	}
}

结果为：