全文纯手打，码字不易，且码且珍惜~
--------------------------------------------OOP封装--------------------------------------------
//封装一个类：用来管理普通人的特性和行为
//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+"\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);//多态
}
//扩展，动态绑定
//动态绑定的前提：
//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.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的核心：封装一个类，把数据抽象出来，再把方法抽象出来，构成一个整体
//封装：为了提高安全性、重用性
//继承：为了提高重用性、子类生成的效率
//多态：为了实现统一管理（统一性）、高效性
//抽象：为了提高效率、简化业务逻辑