java面向对象基础

最新推荐文章于 2024-10-21 16:46:06 发布

原创最新推荐文章于 2024-10-21 16:46:06 发布 · 108 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Java

2Java面向对象专栏收录该内容

13 篇文章

订阅专栏

类实例化方法——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;
}
}