疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java基础之封装、继承、多态、抽象


 

   

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

  //1、类的概念:人类在认识客观世界时,发现某些事物具有共同特性,共同结构,共同行为。

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

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

  //3、类的使用:先构造对象(new+构造器),再通过对象的方法来完成业务(对象名。方法名)

  class Person{

  //人的属性(域、字段、实例变量、成员变量)

  private String name;//姓名

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

  private Date birthday;//生日

  //构造器(1、方法名和类名相同 2、没有返回值)

  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+" 性别"+(sex?"男":"女")+" 生日"+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+" 它的半径是:"+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);//多态

  }

  //扩展,动态绑定

  //动态绑定的前提:

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

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

  //3、父类的对象变量指向了不同的子类对象

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

  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[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的核心:封装一个类,把数据抽象出来,再把方法抽象出来,构成一个整体

  //封装:为了提高安全性、重用性

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

  //多态:为了实现统一管理(统一性)、高效性

  //抽象:为了提高效率、简化业务逻辑