java面向对象基础

类实例化方法——new、反序列化、反射、克隆。

事物认识过程：接触新事物——>有什么特征(属性)——>干什么用(功能，方法)——>怎么用(方法的具体实现) 

package Farmpackage;
*接口(interface)——Java只支持单继承，接口解决了多继承。
*接口是特殊的继承。

 *接口特点:没有构造器；public/abstract——接口； static/final——属性、方法都是抽象的；接口间多继承；类可以扩展另一个类，同时实现多个接口。
 *接口在需要使用的类进行实例化——implement
 *应用条件:广泛用于很多对象；

*功能——使上传型为多个类型(定义类型)；防止客户端实例化，确保仅存一个该接口；

 interface AddGrassable {
 void addGrass(int num);
}
 

package Farmpackage;
*抽象类(abstract)——至少包含一个抽象方法(可有实例化方法)；
public abstract class Product {
 *final——方法不能重写，类不能继承，属性不能更改。
 public static final int MAX_COUNT=40;//(最大产量)定义常量标准格式
 private String name;
 private boolean isRipe;
 private int forNum=0;
 public static final int MAX_FORNUM=4;
 protected int prodectCount=MAX_COUNT;
 public Product(String string){
 name=string;
 isRipe=false; 
 }
 *定义方法
 public void getProdects(){
  System.out.println(name+"收获了"+prodectCount+"kg农产品");
 }
public boolean isRipe(){
  if(forNum==MAX_FORNUM){
   return true;
  }else{
   forNum+=1;
   return false;
  } 
 }
 public abstract void steal(int num);
*抽象方法：只允许声明，不允许实现+不能用"final"修饰；
 * 实例化由子类完成 
 public abstract void addBug(int num);
 public String getName() {
  return name;
 }
}

package Farmpackage;
public class FarmTest {
 * 类变量和方法——static
 public static void main(String[] args) {
  Player t = new Player("张山");
  Product p = new Field("张山的牧场", "山羊");
  t.doBadThing(p);
  System.out
    .println("---------------------------------------------------");
  p = new Farm("张山的农田", "胡萝卜");
  t.doBadThing(p);
 }
}
 

 package Farmpackage;
*类(封装)——所代表对象的属性和行为。

*封装的表现：隐藏——访问修饰符、模块化{}

*setAccessable()用于设置封装性，更改后可使用一次
 * {}——该括号就是属性的极限，属性在哪个{}内定义就只有在那里面可见、可用。
 * 同名的属性就像在圆圈里往外走——看见的总是最近的变量。
public class Farm extends Product implements AddGrassable {
 private String vegetableName;// 变量定义标准格式(private修饰)；通过get(读)/set(写)方法来设置或获得属性；
 private int grassNum;// 属性（成员变量（全局变量=实例成员变量））全局变量会赋给默认值；
 * 构造方法——根据接收的值，给对象的属性赋值。特点——无法继承；方法名与类名相同；无返回类型；可有参；可重载
  * 构造器实现继承的方法——先初始化父类属性(子类构造方法第一条语句为super())，再初始化自己的属性。
  * 原理：子类构造方法存在否—子类构造方法第一句为super()否—父类有符合的构造方法吗？
 public Farm(String string, String vegetable) {
  super(string);
  vegetableName = vegetable;
 }
 public void addBug(int num) {// 局部变量--方法体中定义的变量和方法中的参数
  System.out.println("你在" + this.getName() + "放了" + num + "只害虫");
  prodectCount -= num;
 }
 public void steal(int num) {
  System.out.println("你偷取了" + this.getName() + num + vegetableName);
  prodectCount -= num;
 }
 public void addGrass(int num) {
  prodectCount -= num;
  System.out.println("你往" + this.getName() + "放了" + num + "杂草");
 }
}

 package Farmpackage;
*继承(extends)——一切类都继承于Object类

*有血缘关系的，一脉相承的才叫继承，得到的是其的裸体；而接口是附属物，是其可有可无的装饰，没有接口他还是他。没有了继承他就不再是他——接口与继承的关系
 *

修饰符	本类	同胞子类	异包子类	异包非子类
public	Y	Y	Y	Y
protected	Y	Y	Y	X
friendly	Y	Y	X	X
private	Y	X	X	X

 *方法的重写：纵向；一切(方法名、参数、返回类型)不变，只是改变实现；访问权限只能改小；
 *方法的重载：横向；方法名同，参数(个数、类型)不同
public class Field extends Product {
 private String animalName;
 public Field(String string, String animalName) {
  super(string);
  this.animalName = animalName;
 }
 public void addBug(int num) {
  System.out.println("你在" + this.getName() + "放了" + num + "只害虫");
  prodectCount -= num;
 }
*内部类——匿名内部类；
 * 方法的内部类——不能用访问修饰符修饰；不能为static；用作传给该方法的参；final修饰的该方法变量；引用方法的局部变量，
 * 匿名内部类——没有类名和构造函数；申明时就实例化；
 public void steal(int num) {
  System.out.println("你偷取了" + this.getName() + num + animalName);
  prodectCount -= num;
 }
}

 package Farmpackage;

public class Player {
 private String name;

 private int badthingNumber;

 public Player(String string) {
  name = string;
  badthingNumber = (int) (Math.random() * 10);
 }

 public void doBadThing(Product p) {
  while (!(p.isRipe())) {
   int num = (int) (Math.random() * 3);
   switch (num) {
   case 0:
    p.steal(badthingNumber);
    break;
   case 1:
    p.addBug(badthingNumber);
    break;
   case 2:

     * 多态——方法根据不同类型的参数执行出来的结果也不同。

   if (p instanceof AddGrassable) {
      * 上传型对象——接受父类参数的地方也可以接受子类参数
     AddGrassable impl = (AddGrassable) p;
     impl.addGrass(badthingNumber);
    } else {
     System.out.println("牧场里不能放草");
    }
   }
  }
  System.out.println("农作物已成熟");
  p.getProdects();
 }
 public String getName() {
  return name;
 }
 public int getBadthingNumber() {
  return badthingNumber;
 }
}