初学——面向对象的三大特征

面向对象的三大特征

我们都知道面向对象的三大特征是：封装、继承、多态
接下来就有我从一个初学者的角度带你们来看这三个特征。

封装

封装就是隐藏内部细节，对外面提供公共访问方法，用private修饰。

   尝试用setxxx/getxxx,或者构造有参和无参构造，给外界提供一个公共的访问方法。

public class Student {
	private String name;//姓名
	private int age;//年龄
	private String gender;//性别
	//setxxx/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 getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}
	//无参构造
	public Student() {
	}
	//有参构造，输出需要getxx获取
	public Student(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
}

public class StudentTest {

	public static void main(String[] args) {
		Student s=new Student();
		//通过setxxx赋值
		s.setName("姓名");
		s.setAge(23);
		s.setGender("女");
		//通过getxxx输出
		System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGender());
		//通过有参构造赋值
		Student s2=new Student("成龙",66,"男");
		//输出还是用getxxx方法
		System.out.println(s2.getName()+"---"+s2.getAge()+"---"+s2.getGender());
		

	}

}

输出：

   姓名---23---女
   成龙---66---男

继承

继承
需要定义独立的类,将其他类的共性内容抽取到该独立的类中,让其他类和这个独立类的产生一种关系: "继承"关系

 继承的好处：
 1.提高了代码的复用性
 2.提高了代码的维护性
 3.类和类产生这种关系是多态的前提

继承的特点：

 1.在Java语言中，类和类之间只支持单继承，不支持多继承
 2.虽然不支持多继承，但类与类之间是可以多层继承的

继承中的注意事项:

1.子类继承父类,可以继承父类中所有的非私有的成员
2.子类继承父类,不继承父类构造方法,但是可以通过一个关键字来访问父类的构造方法
3.不要为了使用部分功能而去使用继承

注意：
当A类如果是B类的一种，或者B类是A类的一种，这个时候使用继承（他们之间是一种"is a"的关系）

继承中的成员关系

成员变量

遵循一个"就近原则"

 1.在子类的局部位置找，找到就使用它
 2.如果局部位置没有，在子类成员位置找
 3.如果找不到，就在父类成员位置找
 4.如果还找不到就报错

public class Fu {
    int num=12;
}
public class Zi {
	int num=34;
	public void show() {
		int num=78;
		System.out.println(num);
	}
}
public class Test {
	public static void main(String[] args) {
		Zi z=new Zi();
		z.show();
		
	}
}

输出结果：

  78

构造方法

子类是不能继承父类的构造方法的,但是通过super()来访问父类的构造方法
在继承中,子类中所有的构造方法都默认访问父类的无参构造方法;

注意：

super():如果在子类的构造方法显示给出了,必须写在第一句,否则可能出现父类初始化多次(可以省略不写，系统默认给出)

成员方法

先从子类范围找，如果没有在从父类范围找。（和成员变量相似）

this和super的区别

访问成员变量:
	this.变量名  :访问本类的成员变量
	super.变量名: 访问父类的成员变量
访问成员方法:
 	this.方法名() ;访问本类的成员方法
	super.方法名();访问父类的成员方法
	访问构造方法:
	this():表示访问的是本类的无参构造方法
	this(xx);表示访问本类的有参构造方法

	super() ;表示访问父类的无参构造方法
	super(xx); 表示访问父类的有参构造方法

class Fu{
	
	public int num = 12 ;
}
class Zi extends Fu{
	public int num = 23;
	
	public void show() {
		int num = 45 ;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}
	
}
public class Test2 {

	public static void main(String[] args) {
		Zi z = new Zi() ;
		z.show();
	}
}

输出结果:
 45
 23
 12

多态

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

多态的前提条件:

1.必须有继承关系
2.方法重写 ,子类继承父类,将父类的功能覆盖掉,使用子类最具体的功能!
3.父类引用指向子类对象

多态的好处：

1.提高代码的复用性（有继承保证）
2.提高了代码的扩展性（有多态保证）

多态的弊端：不能访问子类的特有功能

需要向下转型（将父类应用强转为子类的引用）

public class Person {
	private String name ;
	private String gender;
	private  int age;
	
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Person(String name, String gender, int age) {
		super();
		this.name = name;
		this.gender = gender;
		this.age = age;
	}

	public void sleep() {
		System.out.println("人总要睡觉");
	}
}
public class Student extends Person {

	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Student(String name, String gender, int age) {
		super(name, gender, age);
		// TODO Auto-generated constructor stub
	}
	public void sleep() {
		System.out.println("学生应该保持充足的睡眠");
	}
	public void study() {
		System.out.println("好好学习");
	}
}
public class StudentTest {
	public static void main(String[] args) {
		//向上转型
		Person p=new Student("小明","男",18);
		System.out.println(p.getName()+"---"+p.getGender()+"---"+p.getAge());
		p.sleep();
		//向下转型
		Student s=(Student)p;
		s.study();
	}
}