面向对象的三大特征
我们都知道面向对象的三大特征是:封装、继承、多态
接下来就有我从一个初学者的角度带你们来看这三个特征。
封装
封装就是隐藏内部细节,对外面提供公共访问方法,用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();
}
}