面向对象的三大特点
封装、继承、多态
1.封装
何为封装?封装即为将类的属性和方法隐藏起来,不对外界展示内部结构,只提供公共的方法对其进行访问。
为了保证对象属性和行为的安全,保证类内部数据结构的完整性,用户只能通过公共的方法对对象的属性进行更改。需要进行封装的属性和方法必须用private修饰。
package encapsulate;
public class Class {
private String name;
private int age;
private String sex;
private String id;
//设置get、set方法
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 String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
//私有方法,在其他类中无法被调用
private void sing() {
System.out.println("hello world!");
}
}
private是权限修饰符,被private修饰的属性和方法只能被本类访问,而无法被其他类访问。若想改变private修饰的属性的值,只能通过get、set方法来改变和访问。因此避免了信息的泄露、避免了他人非法修改属性的值。
package encapsulate;
public class Class1 {
public static void main(String[] args) {
Class cl=new Class();
cl.setSex("Bin");
System.out.println(cl.getSex());
}
}
2.继承
2.1类的继承
java继承的基本思想是基于某个类,对其进行扩展,制定出一个新的类。原来的类成为父类或基类,扩展出来的新类称为子类。子类可以继承父类所有的属性和方法,也可以直接重写父类中的某些方法。
**注意:一个子类只能继承一个父类,但是一个父类可以有多个子类,但是接口允许多继承(注意接口和类的区别)
package 继承;
public class Student extends Humen {
public static void main(String[] args) {
Student stu=new Student();
stu.age=20;
stu.sex="男";
stu.eat();
stu.sleep();
}
public Student() {
System.out.println("我是子类的构造方法");
}
}
class Humen{
private boolean life;
public String sex;
public int age;
public void eat() {
System.out.println("我正在吃饭");
}
public void sleep() {
System.out.println("我正在睡觉");
}
private void live() {
System.out.println("我是活的");
}
public Humen() {
System.out.println("我是父类的构造函数");
}
}
上面的一段程序有一个关键字extends,表示继承。同时子类程序中没有声明任何属性和方法,但是子类对象却可以调用父类的所有属性和方法。(继承)
读者可以先来想一下输出结果是什么,接下来是输出结果:
程序流程:1.子类创建一个对象,调用子类构造函数,子类构造函数第一行隐式调用父类构造函数,然后执行子类构造函数中的语句。
2.子类对象调用从父类继承来的属性和方法。
2.2接口的继承
接口是一种特殊的抽象类,接口是不同类或者不同对象相同方法的集合,其属性均为常量,方法均为抽象方法(不可创建对象的原因)。话不多说,直接上代码:
package 接口的继承及其实现;
public interface Controler {
final String id="遥控器"; //设置其编号
final int boundrate=115200; //设置通信时的波特率
public boolean up_date(); //控制器更新的方法
public boolean ok(); //控制器确认的方法
public int add_chinal(); //控制器增加频道
public int reduce_chinal(); //控制器减小频道
}
package 接口的继承及其实现;
public interface Controler2 {
}
package 接口的继承及其实现;
public interface Controler3 extends Controler,Controler2 {
}
package 接口的继承及其实现;
public class Television implements Controler,Controler2{
/*
*@Override表示重写
*
*/
@Override
public boolean up_date() {
// TODO Auto-generated method stub
return false;
}
@Override
public boolean ok() {
// TODO Auto-generated method stub
return false;
}
@Override
public int add_chinal() {
// TODO Auto-generated method stub
return 0;
}
@Override
public int reduce_chinal() {
// TODO Auto-generated method stub
return 0;
}
}
上面四个代码片段,前三个都是接口,分别是Controler 、Controler2 、Controler3 ,最后一个是实现类Television 。上面的代码中有一个新的关键词implements,表示实现。一个接口可以继承多个接口;一个类可以实现多个接口,但必须重写所实现接口中的所有抽象方法,否则编译不通过。
3.多态
多态是指某个类在不同的情况下所展现出不同的类型,有利于程序的维护。多态的基础是继承。。。。。不行,上代码吧
package 多态;
public class PolyTest {
public static void main(String[] args) {
//向上转型
People pe=new Student();
pe.age=20;
pe.height=175.2;
pe.nation="中国";
pe.sex="男";
pe.eat();
pe.run();
pe.sleep();
//向下转型
Student st=(Student) pe;
st.id="19980902";
st.study();
}
}
完整的代码将在文末给各位奉上,这里只讲解上面一段代码中的多态形式:
People pe=new Student(); 创建的类型与调用的构造函数不符(必须是创建父类对象,调用子类的构造函数,即“=”右边必须是左边的子类或者左边接口的实现类) 这句话的意思是创建了一个People类实例pe,但是其引用对象为Student类型,也就是说pe实际上是一个Student类型的实例,这种创建对象的方法称为向上转型。
实例化的对象在编译阶段调用变量属性时,只会调用父类与子类共同拥有的属性,不会调用子类特有的属性,在运行阶段调用的也是父类的属性;
实例化的对象在编译阶段调用方法时,只会调用父类与子类共同拥有的方法,不会调用子类特有的方法,在运行阶段调用的是子类的方法。(注意与变量的区别)
简单的记法:变量编译运行都看左边,方法编译看左,运行看右。
上面代码的第二段,通过向下转型,可以将实例化的对象转换成子类对象,这时可以调用子类特有的变量和方法,而且运行时调用的也是子类的变量和方法。
上述源码