java随笔——面向对象（下）

package we;
class Animal
{
	String name;//基类构造函数
	Animal()
	{
		System.out.println("父类构造");
	}
	void shout()
	{
		System.out.println("动物声音");
	}
}
class Dog extends Animal//Dog继承Animal类
{
	Dog()//子类构造函数
	{
		System.out.println("子类构造");
	}
	public void printN()
	{
		System.out.println("name="+name);
	}
}
public class me
{
	public static void main(String[] args)
	{
		
		Dog p=new Dog();
		p.name="沙皮狗";
		p.printN();
		p.shout();
	}
}
/*
 * 继承：子类会自动拥有父类所有可继承的属性和方法。
 * extends为继承关键字。
 * 父类先构造，然后在构造子类。
 */

//重写父类方法
package we;
class Animal
{
	
	void shout()
	{
		System.out.println("动物动作");
	}
}
class Dog extends Animal//Dog继承Animal类
{
	void shout()//重写
	{
		System.out.println("汪汪.....");
		super.shout();//
	}
}
public class me
{
	public static void main(String[] args)
	{
		Dog p=new Dog();
		p.shout();//shout访问父类成员
	}
}
/*
 * 子类中相同返回型，方法名，参数列表，就可以重写父类。
 */

//final关键字
package we;
final class Animal//final修饰，此类不能再被继承
{
	public final void shou()//final修饰，此函数不能再被重写
	{
		System.out.println("发出动物叫声");
	}
}
class Dog extends Animal//报错，因为Animal是final修饰
{
	public void shou ()
	{
		System.out.println("汪汪.......");
	}
}
public class me
{
	public static void main(String[] args)
	{
		final int num=4;
		num=1;//报错，final修饰的变量不能再被修改。
		final String name;//报错，final修饰的变量虚拟机不会进行初始化，需要自己初始化。
//	    System.out.println("name="+name);
	}
}
/*
 * final关键字修饰的类不能被继承
 * final关键字修饰的函数不能被重写
 * final关键字修饰的变量需要初始化
 */

//abstract:抽象类
package we;//抽象类
abstract class Animal
{
	public int n;
}
class Dog extends Animal
{
	void printf()
	{
		System.out.println(n);
	}
}
public class me
{
	public static void main(String[] args)
	{
		Dog p=new Dog();
//		Animal u=new Animal();//抽象类是没有方法体的
		p.printf();
	}
}
/*
 * 抽象类是客观存在的，没有方法体，可以通过继承的方法来进行实现
 */

//interface与inplements
package we;
interface Animal
{
	void run();
}
class Dog implements Animal
{
	public void run()
	{
		System.out.println("跑");
	}
}
public class me
{
	public static void main(String[] args)
	{
		Dog  p=new Dog();
		p.run();
	}
}
/*
以下摘自博客:
接口和抽象类有什么区别 :
你选择使用接口和抽象类的依据是什么？ 

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。
抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。
人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.
所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。
第一点． 接口是抽象类的变体，接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。
第二点． 接口可以多继承，抽象类不行
第三点． 接口定义方法，不能实现，而抽象类可以实现部分方法。
第四点． 接口中基本数据类型为static 而抽类象不是的。
当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的
所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。
 */