JAVA # (一)面向对象

类

类是事物的静态属性和动态可执行操作所结合起来的概念,用来模拟事物

java中对象的实现

A aa = new A();//对象的引用放在栈中,对象放在堆中
aa 在栈中,但aa只是引用,是一个地址,指向了在堆中的一块内存

程序的执行过程

从外存中取得代码,放入内存中,与操作系统中的代码结合,组成执行代码再执行

访问控制符

就是接口,用来修饰类的成员,对类中的成员进行访问限制.
在类的内部,访问控制符是透明的.
public: 可在外部通过本类名访问,本类名对象访问
private: 只能在类内部访问.

类的构造函数

一个接口,在构造对象的时候,直接对对象赋值的一种特殊方法.
与类名同名,分为有参和无参(函数的重载).

this指针

那个对象调用this,this指向谁.
构造函数中:this代表当前正在创建的对象.
普通函数中:this指正在调用函数的对象的指针.

static

一个类的公共静态属性区,用static修饰的成员在此区中,可以通过类名访问,也可以通过对象名访问.
应用:知道此类创造了多少对象;要求一个类只能生成一个对象.
tip:静态方法不能使用this和super修饰.

继承

子类继承父类
优点:1.代码复用.	2.形类的层次体系结构.	3.为多态创造条件.
注意:
	1.子类内部可以访问父类的非私有成员.
	2.子类对象可以访问父类的非私有成员.
	3.子类类名可以访问父类的非私有成员,父类静态修饰的成员.
	4.JAVA只支持单继承,不支持多继承.
	5.子类不能继承父类的构造函数,要想在子类的构造方法中调用父类的构造方法要用super.
	6.虽然私有不能被继承,但是任然会占用物理空间.

super的使用

class A
{
	public int i;
	public int j;
	public A(){}
	public A(int i,int j)
	{
		this.i = i;this.j = j;
	}
}
class B extends A
{
	public int k;
	public B(){}
	public B(int i,int j,int k)
	{
		super(i,j)
		this.k = k;
	}
}
public class test
{
	public static void main(String[] args)
	{
		B bb = new B();
	}
}

1.每个子类构造方法的第一条语句都隐式调用super();如果父类没有无参构造函数,编译报错
2.	如果显示调用super()则必须在构造函数第一条语句.
3.	super()如果不写,编译器会自动添加.
4.	写super()前提是,父类有无参构造;写super(参数)前提是,父类有有参构造.
5.	调用父类构造函数必须借助于super.
总结:父类有无参构造或者有参构造,才可能使用super,同时必须是第一条.

父类方法的重写

重写父类	:在子类中重新定义父类中的方法,方便子类使用.
重写要求:重写方法必须和被重写方法具有相同名称,参数列表,返回类型;
		同时权限高于父类中的权限.

class A
{
	public void f()
	{
		System.out.println("aaa");
	}
}
class B extends A
{
	public void f()
	{
		super.f();//调用父类的方法
		System.out.println("bbb");
	}
	public void f(int i)
	{
		System.out.println("fff");
	}
}
public class test
{
	public static void main(String[] args)
	{
		B bb = new B();
		bb.f();
		bb.f(1);
	}
}

多态

多态:一个父类的引用类型变量它即可以指向父类对象,也可以指向子类对象;
	同时指向对象后任然可以调用其指向对象的方法,这就叫多态.
优点:
	同一串代码可以做不同的事.

class A
{
	public void f()
	{
		System.out.println("aaa");
	}
}
class B extends A
{
	public void f()
	{
		super.f();//调用父类的方法
		System.out.println("bbb");
	}
	public void f(int i)
	{
		System.out.println("fff");
	}
}
public class test
{
	public static void main(String[] args)
	{
		B bb = new B();
		bb.f();
		A aa = new A();
		aa = bb;
		aa.f();
	}
}

总结:
1.子类对象的引用可以赋给父类对象引用.
2.父类对象引用可以访问子类从父类中继承到的成员,不能访问子类特有的成员.
3.多态结合重写可以达到同一代码不同效果.
4.当父类引用指向子类时,才能用强制类型转换.

抽象类

抽象类:一个类族的最顶层的类,拥有抽象方法的类,关键字abstract.
抽象方法:没有具体的执行步骤,有abstract修饰,结尾有分号的方法.
tip:有抽象方法就一定是抽象类,是抽象类不一定有抽象方法.

抽象类与多态:
1.父类抽象,子类可抽象也可实现抽象方法后成为非抽象.
2.父类非抽象,子类可以抽象.
3.可以定义一个抽象类的引用,但不可以定义抽象类的对象.

接口

接口:抽象方法和常量值的集合.是一个特殊的抽象类.
注意:
	1.接口中的属性必须是public static final
	  接口中的方法必须是public abstract
	2.类能实现接口,不能继承接口
	3.接口可以继承多个接口
	4.若类只实现接口的部分方法,这个类必须是抽象类
	5.类继承父类时也可实现接口,但extends必须写在implements前
	6.不可以直接new出接口对象,只能通过接口定义接口对象,并将其指向接口对象,实现多态.

interface It
{
	public static final int i = 20;
	public abstract void f();
	//public void f(){} ___error
	//只能有公有静态最后属性和公有抽象方法
	//接口中定义的属性只能是public static final(共有的静态的不允许被修改的)
	//接口中定义的方法只能是public abstract(共有的抽象的），但是这些修饰符可以被省略
	//一个接口可以继承多个接口，与class不同的地方
}
interface It2
{
	int i = 20;
	void f();
}

//class C extends It2
//{	
//}__________________error
//*****类不能继承接口，只能实现接口


abstract class C implements It2
{
	
}
//这个类只实现接口的部分方法，则这个接口必须为抽象类
//用抽象类来实现接口，这个抽象类将接口中成员实现下来不用extends用implements


class B implements It2
{
	public void f()
	{
		//i = 12;-------error原因是final修饰
		System.out.printf("%d\n",i);
	}//这样写的原因是，将继承的抽象方法重写成了非抽象的，调用final修饰的i
}
//用类来实现接口，其中用非抽象类来实现了抽象方法，原因是在子类中继承的抽象方法已经被实际化


class D extends B implements It2
{

}
//类对类的继承和对接口的实现一起发送时，则extends写在implements前面，不然会报错


interface It3
{
	void f();
}
class E implements It3
{
	public void f()
	{
		System.out.printf("EEEEEE");
	}//重写：1、姓名，形参，返回值一样。2、权限必须高。
	public void g()
	{
	}
}


class A
{
	public static void main(String[] args)
	{
		//It3 it = new It();----error
		//接口对象不能用new创建
		It3 it;
		//但可以定义一个接口引用类型的变量,并将其指向实现接口的对象，达到实现多态的目的
		//-----OK，这是直接用接口It定义一个对象it
		it = new E();
		it.f();
		//it.g();----error，通过接口引用只能调用从父接口实现的成员，不能调用子类特有成员
		
		
	}
}