第三周学习记录之面向对象

代码块

在Java中使用{}包裹起来的内容

分类

局部代码块

在方法中定义的{}

构造代码块

定义在类中,方法外的{}

静态代码块

在构造代码块前面加上static的代码块,会随着类的加载而加载.

优先级:
	静态代码块	>	 构造代码块 	>	局部代码块

继承

定义的一个独立的类,并且这个独立的类将其他类中的共同的属性和行为抽取到自己中,让其他类和独立的这个类产生一种关系,这种关系叫"继承关系"

格式:
	子类名	extends 父类名{
	}

继承的特点

1)类和类之间只支持单继承,不支持多继承
2)可以多层继承

例题:

//学生类和老师类都有姓名,年龄,性别,身高这些属性,学生类和老师类
class School{
	private String name;		//姓名
	private int age;			//年龄
	private String sex;			//性别
	private int height;			//身高
	//无参构造
	public School() {
		super();
	}
	//有参构造
	public School(String name, int age, String sex, int height) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.height = height;
	}
	//setxxx/getxxx
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getHeight() {
		return height;
	}
	public void setHeight(int height) {
		this.height = height;
	}	
	public void show() {
		System.out.println("姓名为:"+name);
		System.out.println("性别为:"+sex);
		System.out.println("年龄为:"+age);
		System.out.println("身高为:"+height);
	}
	
}
//学生类
class Student extends School{

	public Student() {
		super();
	}

	public Student(String name, int age, String sex, int height) {
		super(name, age, sex, height);
	}
}
//老师类
class Teacher extends School{

	public Teacher() {
		super();
	}

	public Teacher(String name, int age, String sex, int height) {
		super(name, age, sex, height);
	}
	
}
public class SchoolTest {

	public static void main(String[] args) {
	//测试学生类
		Student s = new Student("庄周",23,"男",192);
		s.show();
		System.out.println("------------------");
		//测试老师类
		Teacher t =new Teacher("墨子",45,"男",189);
		t.show();
	}
}

多态

一个事物在不同时刻的体现

多态的前提条件

1>要有继承关系
2>要具有方法重写
3>父类引用指向子类对象

父类名	对象名 = new 子类名();

多态的弊端

不能访问子类的特有功能
解决:

强转:父类为人类,子类为老师和学生
向上转型:
	Person f = new Student();
	Person f1 = new Teacher();
向下转型:
	Student z = (Student)f;
	Teacher t = (Teacher)f1;

举例:

南方人和北方人都有姓名,年龄以及性别,都有"吃饭"的功能,但是南方人经常吃米饭,北方人经常吃面条,
南方人主要还去经商,北方人主要考学,请使用面向对象编程并且使用多态形式进行测试南方人和北方人!
public class Person {
	private String name;		//姓名
	private int age;			//年龄
	private String sex;			//性别
	//共有行为
	public void eat() {
		System.out.println("是个人都会吃饭");
	}
	//无参构造
	public Person() {
		super();
	}
	//有参构造
	public Person(String name, int age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	//setxx/getxx
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	
}
public class NorthPeoper extends Person {

	public NorthPeoper() {
		super();
	}

	public NorthPeoper(String name, int age, String sex) {
		super(name, age, sex);
	}

	@Override
	public void eat() {
		System.out.println("北方人喜欢吃面");
	}
	//私有行为:考大学
	public void inCollege() {
		System.out.println("北方人经常考大学出人头地");
	}
	
}
public class SouthPeoper extends Person {

	public SouthPeoper() {
		super();
	}

	public SouthPeoper(String name, int age, String sex) {
		super(name, age, sex);
	}

	@Override
	public void eat() {
		System.out.println("南方人吃白米饭");
	}
	//私有行为
	public void doBoos() {
		System.out.println("南方人通过经商出人头地");
	}
	
	
}
public class PersonTest {
	public static void main(String[] args) {
		//向上转型测试南方人
		Person p = new SouthPeoper("白展堂",25,"男");
		System.out.println("姓名为:"+p.getName());
		System.out.println("年龄为:"+p.getAge());
		System.out.println("性别为:"+p.getSex());
		p.eat();
		//向下转型
		SouthPeoper s = (SouthPeoper)p;
		s.doBoos();
		System.out.println("------------");
		//测试北方人
		Person pp = new NorthPeoper("吕秀才",28,"男");
				System.out.println("姓名为:"+pp.getName());
				System.out.println("年龄为:"+pp.getAge());
				System.out.println("性别为:"+pp.getSex());
				pp.eat();
				//向下转型
				NorthPeoper n = (NorthPeoper)pp;
				n.inCollege();	
		
	}
}

抽象类和接口

抽象类

一个类中的功能,有方法,但没有具体定义,需要定义该类为抽象类

关键字: abstract

特点

1>如果一个类中有抽象方法,那么该类一定是抽象类,反之则不然
2>抽象类不能创建对象
3>抽象类需要通过子类进行实例化,父类引用指向子类对象
4>

抽象方法的格式:
 权限修饰符 abstract 返回值类型 方法名(形式参数) ;
 abstract:表示抽象
 可以修饰类,可以修饰成员方法

接口

接口所体现出来的是事物本身所不具备的,经过一些特殊的行为获得的功能

关键字 interface

注意事项

1>接口只能定义抽象方法
2>接口不能实例化
3>接口子实现类:
			接口名  对象名  =new 子实现类名(); 
4>通过接口的子实现类来进行实例化

成员特点

	成员方法:只能是抽象方法,存在默认的修饰符,public abstract
	成员变量:只能是常量.存在默认的修饰符:public static final
	构造方法:接口不存在构造方法

方法返回值
	基本数据类型:需要什么数据类型,在调用方法的时候,就使用该具体类型去接收!
	引用数据类型:
		返回值如果是:
				具体类:需要返回该具体类的对象
				抽象类:需要返回该抽象类的子类对象
				接 口:需要返回该接口的子实现类对象
	关于形式参数问题的研究(引用类型!)
	方法形式参数两种类型:
		基本数据类型:形式参数的改变对实际参数没有影响!
		引用数据类型:形式参数的改变对实际参数有直接的影响!
				具体类:实际调用该方法,实际参数需要传递该具体类的对象!
				抽象类:那么调用该方法,实际参数需要传递该抽象类的子类对象
				接口:那么调用该方法,实际参数需要传递该接口的子实现类对象

举例:

设计一个Java程序

		(1)定义一个接口CanCry，描述会吼叫的方法public void cry()
		(2)分别定义狗类（Dog）和猫类（Cat），实现CanCry接口。实现方法的功能分别为：
				打印输出“我是狗，我的叫声是汪汪汪”、“我是猫，我的叫声是喵喵喵”
				
		(3)定义一个主类G， 
			定义一个void  makeCry(CanCry c)方法，其中让会吼叫的事物吼叫。
			在main方法中创建狗类对象（dog）、猫类对象（cat）、G类对象（g），用
		g调用makecry方法，让狗和猫吼叫。
		
			//定义一个接口CanCry，描述会吼叫的方法public void cry()
			public interface CanCry {
				public void cry();
			}
			//定义一个猫类（Cat）
			public class Cat implements CanCry {

				@Override
				public void cry() {
					System.out.println("我是猫，我的叫声是喵喵喵");

				}

			}
			//定义狗类（Dog）
			public class Dog implements CanCry {

				@Override
				public void cry() {
					System.out.println("我是狗，我的叫声是汪汪汪");

				}

			}
			public class G {
				//定义一个void  makeCry(CanCry c)方法，其中让会吼叫的事物吼叫
				void makeCry(CanCry c) {
					c.cry();
				}
				public static void main(String[] args) {
					//创建狗类对象(dog)
					Dog dog = new Dog();
					//创建猫类对象(cat)
					Cat cat = new Cat();
					//创建G类对象(g)
					G g = new G();
					//调用makecry方法
					g.makeCry(cat);
					g.makeCry(dog);
				}
			}

	

内部类

权限修饰符

private
	只允许本类访问
默认
	允许本类,同一个包下的子类,无关类访问
protected
	允许本类,同一个包下的子类,无关类访问
public 
	权限最大,允许同一个包下的子类,不同包的子类,无关类访问

分类:
内部成员类:定义在外部成员位置
局部内部类定义在外部成员方法中

通过外部类访问成员内部类的成员
		外部类名.内部类名 对象名 = 外部类对象.内部类对象();
外部类访问静态的成员内部类的成员
		外部类类名.内部类名 对象名  = new 外部类名.内部类名();

匿名内部类:

new 类名/接口名(){
				重写方法;
		};

匿名内部类的本质:继承了该类或者是实现了该接口的子类对象
举例

定义一个Father和Child类，并进行测试
		要求如下：

	Father类为外部类，类中定义一个私有的String类型的属性name，name的值为“zhangjun”。
	Child类为Father类的内部类，其中定义一个introFather()方法，方法中调用Father类的name属性。
	定义一个测试类Test，在Test类的main()方法中，创建Child对象，并调用introFather ()方法。


	//Father外部类
	class Father{
		//定义一个私有属性name
		private String name = "zhangjun";
		
		//定义一个Child的内部类
		class Child{
			//定义一个introFather()的方法
			public void introFather() {
				System.out.println(name);
			}
		}
	}
	//测试类
	public class Test {
		public static void main(String[] args) {
			Father.Child fc = new Father().new Child();
			fc.introFather();
		}
	}