Java基础-OOP特性之封装、继承、多态、抽象

全文纯手打，码字不易，且码且珍惜~

--------------------------------------------OOP封装--------------------------------------------

//封装一个类：用来管理普通人的特性和行为

//一、类的概念：人类在认识客观世界时，发现某些事物具备共同特性，共同结构，共同行为。

//　　为了方便，咱们就将它们集合起来，并抽象出一个概念类管理它们，这个概念就是类。

//二、类的组成：标准类由：实例变量、构造器、设定器、访问器和功能方法五个部分组成

//三、类的使用：先构造对象（new+构造器），再经过对象的方法来完成业务（对象名。方法名）

class Person{

　　//人的属性（域、字段、实例变量、成员变量）

　　private String name;//姓名

　　private boolean sex;//ture为男，false为女

　　private Date birthday;//生日

　　//构造器（一、方法名和类名相同 二、没有返回值）

　　public Person(){

　　}

　　public Person(String name,boolean sex,Date birthday){

　　　　this.name=name;

　　　　this.sex=sex;

　　　　this.birthday=birthday;

　　}

　　//设定器：用来为对象设置或改变属性的值

　　public void setName(String name){

　　　　this.name=name;

　　}

　　public void setSex(boolean sex){

　　　　this.sex=sex;

　　}

　　public void setBirthday(Date birthday){

　　　　this.birthday=birthday;

　　}

　　//访问器：用来获取对象的属性值

　　public String getName(){

　　　　return name;

　　}

　　public boolean getSex(){

　　　　return sex;

　　}

　　public Date getBirthday(){

　　　　return birthday;

　　}

　　//功能方法：为了完成业务而设计的方法

　　//返回运算结果，实现简单的加法运算

　　public int add(int x,int y){

　　　　return x+y;

　　}

　　//返回输出信息，重写了父类的方法，这个方法是默认且自动调用的

　　public String toString(){

　　　　SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

　　　　String str=sdf.format(birthday);

　　　　return "姓名："+name+"\t性别"+(sex?"男":"女")+"\t生日"+str;

　　}

}

//变量的概念：计算机内存中的一个存储单元，它的值能够随着程序的运行发生改变

//数据类型：基本类型（存储数据自己）、引用类型（存储指向对象的地址）

//Java Application 用来完成业务的类

public class PersonTest{

　　public static void main(String[] args){

　　　　//局部变量：方法或语句块中定义的变量

　　　　String name="刘德华";

　　　　boolean sex=true;

　　　　int age=20;

　　　　//对象变量p1 p2

　　　　Person p1=null;

　　　　p1=new Person();

　　　　person p2=new Person();

　　　　//实现业务：加法运算

　　　　int a=100;

　　　　int b=200;

　　　　int re=p1.add(a,b);

　　　　System.out.println(a+"+"+b+"="+re);

　　　　//实现业务：修改属性

　　　　p1.setName(name);

　　　　p1.setSex(sex);

　　　　p1.setBirthday(new Date());

　　　　System.out.println(p1);

　　　　//如下现实对继承类Student的代码的测试

　　　　Student stu=new Student();

　　　　re=stu.add(50,100);

　　　　System.out.println(re);

　　}

}

 

--------------------------------------------OOP继承--------------------------------------------

//学生是一种普通人，学生有普通人派生而来，成为一种特殊的普通人

//从学生身上能够看到普通人的全部特性，也能够看到只属于学生不属于普通人的特性

//使用继承，让子类在编写时的效率更高了，由于子类与父类分共性不用写了

//使用继承，让父类分代码极大地提升了重用性

public class Student extends Person{

　　//子类的个性

　　private String school;

　　private int score;

　　//子类的构造器

　　public Student(){

　　}

　　public Student(String name,boolean sex,Date birthday,String school,int score){

　　　　super(name,sex,birthday);//借助父类的构造器

　　　　this.school=school;

　　　　this.score=score;

　　}

　　//设定器、访问器代码略过

　　//功能方法：

　　//重写（覆盖）父类的方法add()，大部分状况下方法头不变

　　//为何要重写？由于现有的业务父类完成的不够好，达不到咱们的业务要求。

　　public int add(int x,int y){//此行是方法头

　　　　//业务要求输出：下面这行信息，父类的add方法不行，因此调用子类来运算和输出

　　　　System.out.println("程序调用了Student类（子类）去完成加法运算");

　　　　return x+y;

　　}

}

 

--------------------------------------------OOP多态--------------------------------------------

//经典题型：不一样图形计算面积

//什么是多态：同一类的对象   接受相同的信息   作出不一样的反应

//抽象的平面图形类，里面含有抽象方法area()；抽象类不能被实例化，但它的子类能够。

abstract class Shape{

　　private String type;

　　//构造器

　　public Shape(){}

　　public Shape(String type){

　　　　this.type=type;

　　}

　　//设定器、访问器代码略过

　　//功能方法：

　　//求平面图形的面积：因为不知道求什么图形，从而面积没法具体实现；因此使用抽象方法

　　public abstract double area();

　　//重写父类toString()方法，来知足如今的业务需求

　　@Override

　　public String toString(){

　　　　return "图形是："+type;

　　}

}//shape类结束

 

//子类-圆，圆是平面图形之一

class Circle extends Shape{

　　//子类的个性

　　private double r;

　　//圆的构造器

　　public Circle(String type,double r){

　　　　super(type);

　　　　this.r=r;

　　}

　　//设定器、访问器代码略过

　　//功能方法：

　　//能够经过重写父类代码，来知足新的业务需求

　　@Override

　　public double area(){

　　　　return Math.PI*Math.pow(r,2);

　　}

　　@Override

　　public String toString(){

　　　　return super.toString+"\t 它的半径是："+r+" 它的面积是"+this.area();

　　}

}//Circle类结束

 

//子类-矩形

class Rectangle extends Shape{

　　//个性

　　private int length;

　　private int wide;

　　//构造器

　　public Rectangle(String type,int length,int wide){

　　　　super(type);

　　　　this.length=length;

　　　　this.wide=wide;

　　}

　　//设定器、访问器代码略过

　　//功能方法：

　　public double area(){

　　　　return length*wide;

　　}

　　public String toString(){

　　　　return super.toString+"，长度为："+length+"，宽度为："+wide+"，面积为"+this.area();

　　}

}//Rectangle类结束

//Java Application 业务测试类、业务实现类、体现多态的类；

public class ShapeTest{

　　public static void main(String[] args){

　　　　//第一种方式:简单的多态

　　　　Shape s1=new Circle("圆",5.5);

　　　　Shape s2=new Rectangle("矩形",12,30);

　　　　s1.area();//简单多态

　　　　s2.area();//简单多态

　　　　//第二种方式：多个图形，指定大小

　　　　Circle c1=new Circle("圆",4.5);

　　　　Circle c1=new Circle("圆",5.5);

　　　　Rectangle r1=new Rectangle("矩形",12,30);

　　　　Rectangle r1=new Rectangle("矩形",22,35);

　　　　Shape[] s={c1,c2,r1,r2};

　　　　for(Shape sp:s){

　　　　　　System.out.println(sp);//多态

　　　　}

　　　　//扩展，动态绑定

　　　　//动态绑定的前提：

　　　　//一、多个子类来源于同一个父类

　　　　//二、子类重写了父类的方法

　　　　//三、父类的对象变量指向了不一样的子类对象

　　　　//四、父类的对象变量调用了子类重写后的方法

　　　　int i=(int)(s.length*Math.random());

　　　　for(Shape sp:s){

　　　　　　System.out.println(s[i].toString);//动态取得图形

　　　　}

　　　　//第三种方式：随机产生随机个随机图形，显示出来，并计算它们的总面积

　　　　int n=(int)(10*Math.random())+1;//随机个数

　　　　s=new Shape[n];//存放n个图形的数组

　　　　for(int i=0;i<s.length;i++){

　　　　　　s[i]=randShape();//随机产出图形，并放进数组里

　　　　}

　　　　double areas=totalAreas(s);//求总面积

　　　　System.out.println("以上全部图形的总面积是："+areas);

　　}

　　public static Shape randShape(){

　　　　int n=(int)(2*Math.random());//随机取值0或1

　　　　Shape sp=null;

　　　　swith(n){

　　　　　　case 0: 

　　　　　　　　sp=new("圆",Math.round(100*Math.random()+1)/10.0;//随机半径，保留随机数一位小数

　　　　　　　　break;

　　　　　　case 1:

　　　　　　　　sp=new("矩形",Math.random()*20+1,Math.random()*50+1);//随机长和宽

　　　　　　　　break;

　　　　　　default:

　　　　　　　　sp=null;

　　　　}

　　　　return sp;

　　}

　　public static double totalAreas(Shape[] s){//计算总面积

　　　　double sum=0;

　　　　for(Shape sp:s){

　　　　　　System.out.println(sp);

　　　　　　sum+=sp.area();

　　　　}

　　　　return sum;

　　}

}//ShapeTest类结束

//要习惯将程序（功能、代码）模块化

//OOP四大特性：封装、继承、多态、抽象

//OOP的核心：封装一个类，把数据抽象出来，再把方法抽象出来，构成一个总体

//封装：为了提升安全性、重用性

//继承：为了提升重用性、子类生成的效率

//多态：为了实现统一管理（统一性）、高效性

//抽象：为了提升效率、简化业务逻辑