面向对象的三大特征
- 封装:提高程序的安全性 (数据的准确性)
- 继承:提高代码的复用性 (重复使用性)
- 多态:提高程序的可扩展性和可维护性
学Java,看这一套就够了
一、封装
- 隐藏对象内部的复杂性,只对外公开简单的接口,便于外界调用,提高程序的安全性
- 隐藏实现的细节,仅仅需要关注具体的功能
- 方法的抽取,仅仅需要关注方法的功能 忽略方法实现的细节
- 项目的模块化设计 层次的划分
1、对类的属性进行隐藏
使用private关键字 修饰类的成员变量
private修饰的成员变量 仅仅可以在当前类中直接使用
Public class Person{
private String name;
private String gender;
private int age;
}
2、给每个属性提供公有的get(获取)和set(赋值)方法
public class Person {
private String name;
private String gender ;
private int age;
public void setName(String name){
this.name = name;
}
//定义一个方法 返回当前对象的name属性值
public String getName(){
return name;
}
public void setGender(String gender){
//如果性别是男或者女 那么 正常赋值
if(gender.equals("男")|| gender.equals("女")){
this.gender=gender;
}else{
//如果性别不是男也不是女 那么给一个默认值为 男
this.gender="男";
}
}
//定义一个方法 返回当前对象的gender属性
public String getGender(){
return gender;
}
public void setAge(int age) {
if (age > 0 && age < 100) {
this.age = age;
}
}
//定义一个方法 返回当前对象对的age属性值
public int getAge(){
return age;
}
public void showInfo(){
System.out.println(name+gender+age);
}
}
测试代码:
public class TestPerson {
public static void main(String[] args) {
//获得Person对象
Person p=new Person();
p.setName("旋涡刘能");
p.setGender("男");
p.setAge(56);
p.showInfo();
//仅仅需要查看人的属性 怎么办?
System.out.println(p.getAge());
System.out.println(p.getGender());
System.out.println(p.getName());
}
}
总结:
- 属性全部隐藏 对象内部的特点不让外界知道 我们仅仅需要关注对象的功能即可 内部的实现 使用了哪些成员 统统不用考虑
- 数据的安全性和和规范性更高
二、继承
java中由已知类创建新类的一种机制,新类拥有已知类的属性和方法,同时,还可以有自己独有的属性和方法
减少相同代码的反复编写,提高代码的复用性,减少编码量,提高程序的可维护度
继承是怎么来的?
是对N多个类的抽像,根据N多个类,抽取出像的部分,归纳为父类,被抽取的类,称为子类
1、在Java中如何实现继承?
在java中使用extends (扩展)实现继承,说明子类是父类的扩展
新类(子类) extends 已知类(父类)
一个父类可以有多个子类,但是一个子类只能有一个直接父类
【例】
1)先准备父类
public class Car {
String color;
String brand;
String type;
public void start(){
System.out.println("一辆"+color+"颜色的"+brand+type+"正在启动");
}
public void speedUp(){
System.out.println("一辆"+color+"颜色的"+brand+type+"正在加速");
}
public void speedDown(){
System.out.println("一辆"+color+"颜色的"+brand+type+"正在减速");
}
}
2)准备子类
Audi
public class Audi extends Car {
// 定速巡航
public void speedKeeping(){
System.out.println("一辆"+color+"颜色的"+brand+type+"启动了定速巡航");
}
}
BMW
public class BMW extends Car {
//温度调节
public void temperatureRegulation(){
System.out.println("一辆"+color+"颜色的"+brand+type+"启动了温度调节");
}
}
测试代码:
public class TestExtends {
public static void main(String[] args) {
Audi au =new Audi();
au.brand="奥迪";
au.color="黑";
au.type="TT";
au.start();
au.speedUp();
au.speedKeeping();
au.speedDown();
BMW b =new BMW();
b.brand="宝马";
b.color="白";
b.type="X5";
b.start();
b.speedUp();
b.temperatureRegulation();
b.speedDown();
}
}
2、super关键字
1、当子类中重写父类中同名的属性
那么在子类中父类的同名的属性被隐藏了
如果在子类中想继续使用父类隐藏的属性 那么要使用super关键字调用父类属性
2、子类对父类同名方法的重新定义叫做方法的重写
子类重写父类方法之后 父类的方法就默认隐藏了
如果子类想继续使用父类中被隐藏的同名方法 那么要使用super关键字调用
public class Test1 {
public static void main(String[] args) {
S s =new S();
s.showName();
s.viewName();
}
}
//父类F
class F{
String name="父类name属性的值";
public void viewName(){
System.out.println(name);
}
}
//子类S
class S extends F{
String name="子类name属性的值";
public void showName(){
System.out.println(name);
System.out.println(super.name);
}
//子类重写父类的viewName()方法
public void viewName(){
System.out.println(name);
super.viewName();
}
}
三、多态
- 一种事物可以有多种表现形态
- 父类作为方法参数 所有的子类对象都可以作为实参
- 父类作为方法的返回值 所有的子类对象都可以返回
子类父类相互转换:
- 子类对象可以声明成父类对象
- 子类拥父类的属性和方法
- 父类不能声明成子类对象
- 父类对象可以通过强制转换声明成子类对象 可以通过编译 但是运行的时候会出现 ClassCastException
- 当父类对象原本就是由子类对象声明而成的 那么强制转换回子类 就不会报错
- 子类声明成父类对象时 调用方法会执行子类的方法
- 编译时 认为是父类 只能调用到父类中声明的方法
- 执行时 认为是子类 占用子类内存 执行子类方法
public class Test1 {
public static void main(String[] args) {
F f =new S();
f.methodA();
//f.methodB();报错
System.out.println(f instanceof F);
System.out.println(f instanceof S);
}
}
class F{
public void methodA(){
System.out.println("父类中的方法");
}
}
class S extends F{
public void methodA(){
System.out.println("子类中重写父类的方法");
}
public void methodB(){
System.out.println("子类中独有的方法");
}
}
本文就先写到这里了,你弄懂面向对象的三大特征了吗?