java面向对象编程的方法是什么
这篇文章主要讲解了“java面向对象编程的方法是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“java面向对象编程的方法是什么”吧！
案例《宠物商店》
1.介绍
功能：
a.宠物商店可以进购宠物，出售宠物；
b.宠物具备吃东西的能力；
c.宠物主人可以在宠物商店购买宠物，可以给宠物起名字，喂养宠物；
2. 分析：
通过以上功能介绍和面向对象编程的思想，可以分析得出如下结果：
a. 宠物商店具备进购和出售宠物的功能（即：宠物商店类，命名为 PetShop），同时商店的宠物需要有一个HashMap集合，名为pets，类似于宠物店中的笼子，存放着各种宠物供顾客购买；
b. 宠物基本各自特有属性，比如说：名字 ，品种等属性（即：宠物类，命名为pet）；
c. 宠物店售卖宠物，那就有各种各样的宠物，比如说:宠物狗，宠物猫（即：宠物狗类，命名为Dog；宠物猫类，命名为Cat）；
d. 宠物主人拥有购买宠物和喂养宠物的功能（即：宠物主人类，命名为：Master）;
3. 编码
通过分析，我们大致了解了我们具体要如何编码，下面就通过编码的形式运用它的四大特性；
a. 封装特性
封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法；
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
了解了封装的概念，我们大致就知道了宠物的特有属性是不可随意改变的，那我们是不是可以把它封装起来，代码如下：
import java.util.ArrayList;
import java.util.List;
/*** 封装特性*1.通过private修饰符修饰，使外部不可直接访问 *2.通过get，set方法向外提供间接的访问
public class Pet {
**/private String id;
private String strain;
private int loveNum;
private int num;
private String name;
public static List<Pet> petSpecies;
static { //静态代码块，只会在第一次执行构造方法的时候执行，初始化petSpecies集合petSpecies = new ArrayList<Pet>();
public Pet(String id,String strain, int loveNum,int num) {
petSpecies.add(new Pet("001","波斯猫",0,9999));
petSpecies.add(new Pet("002","加菲猫",0,9999));
petSpecies.add(new Pet("003","哈士奇",0,9999));
petSpecies.add(new Pet("004","中华田园犬",0,9999));
petSpecies.add(new Pet("005","中华田园猫",0,9999));
petSpecies.add(new Pet("006","牧羊犬",0,9999));
System.out.println("id\t品种");
for(Pet pet:petSpecies) {
System.out.println(pet);
}
}
this.strain = strain;
this.id = id;
this.loveNum = loveNum;
this.num = num;
}
public Pet(){
}
//商店进购宠时，根据商家所选的id和数量给商家返回宠物
public static Pet givePetToShop(String petId,int petNum) {
Pet pet = null;
for(Pet p:petSpecies) {
if(p.getId().equals(petId)) {
pet = p;
pet.setNum(petNum);
return pet;
}
}
return pet;
}
public void eat() {
System.out.println(strain+"正在开心的吃东西");
}
@Override//重写toString方法
public String toString() {
return this.id+"\t" + this.strain +"\t";
}
@Override//重写hashCode方法
public int hashCode() {
return this.getId().hashCode();
}
@Override//重写equals方法
public boolean equals(Object obj) {
if(obj instanceof Pet) {//判断obj类是否为Pet类或Pet的子类
Pet other = (Pet)obj;
if(this.getId().equals(other.getId())) {
if(this.getStrain().equals(other.getStrain())) {
return true;
}
}
}
return false;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public int getLoveNum() {
return loveNum;
}
public void setLoveNum(int loveNum) {
this.loveNum = loveNum;
}
}
b. 继承特性
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为 。
c. 多态性
多态是同一个行为具有多个不同表现形式或形态的能力。
了解了继承和多态的概念，我们大致知道了猫和狗都属于宠物，则猫和狗可以继承宠物的特征和行为，同时每个宠物的行为有不同表现形式，如下代码所示：
/*** 继承特性*1.狗继承了宠物的特性*多态性*2.狗重写了吃的行为，即狗吃的行为是宠物吃的一种表现形式**/public class Dog extends Pet {private String name;
public Dog() {
}
public Dog(String id,String strain,int loveNum,int num,String name) {
super(id,strain,loveNum,num);//调用父类的有参数的构造方法
this.name = name;
}
@Override//重写继承Pet类中的eat()方法
public void eat() {
System.out.println("宠物狗"+name + ":吃的好饱，亲密值加5哦！");
this.setLoveNum(this.getLoveNum()+5);//亲密值加5
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/*** 继承特性*1.猫继承了宠物的特性*多态性*2.猫也重写了吃的行为，即猫吃的行为是宠物吃的一种表现形式**/
public class Cat extends Pet {
private String name;
public Cat() {
}
public Cat(String id,String strain,int loveNum,int num,String name) {
super(id,strain,loveNum,num);
this.name = name;
}
@Override//重写eat()方法
public void eat() {
System.out.println("宠物猫"+name + ":吃的好饱，亲密值加3哦！");
this.setLoveNum(this.getLoveNum()+3);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
*
* @ClassName: PetShop
* @Description: 宠物商店，具有进购宠物、售卖宠物等功能（方法）
*/
public class PetShop {
private static String name;//店铺名称
private static String address;//店铺地址
private boolean isHasCustom;//判断是否有顾客前来
private static HashMap<Pet,Integer> pets;//存放宠物的集合，键是Pet类，值是宠物的数量
static{//静态代码块，初始化商店里的宠物，只会在第一次执行构造方法 的时候执行 name = "好再来";
address = "二七区海为科技园";
System.out.println("---------"+name+"宠物店——"+address+"分店-------------");
Cat boSiCat = new Cat("001","波斯猫",0,3,"");
Cat coffeCat = new Cat("002","加菲猫",0,2,"");
Dog haShiqi = new Dog("003","哈士奇",0,2,"");
Dog tianYuanQuan = new Dog("004","中华田园犬",0,4,"");
pets = new HashMap<Pet,Integer>();
pets.put(boSiCat, boSiCat.getNum());
pets.put(coffeCat,coffeCat.getNum());
pets.put(haShiqi, haShiqi.getNum());
pets.put(tianYuanQuan,tianYuanQuan.getNum());
}
public PetShop(String name, String address) {
super();
this.isHasCustom = false;
}
public PetShop() {
this.isHasCustom = false;
}
/**
* 展示宠物
*/
public void showAllPet() {
System.out.println("编号\t品种\t数量");
Set<Map.Entry<Pet,Integer>> entry = pets.entrySet();
Iterator it = entry.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
//依据id返回宠物
public Pet getPetById(String id) {
if(id != null) {
for(Pet p:pets.keySet()) {
if(p.getId().equals(id)) {
return p;
}
}
}
return null;
}
/**
* 进购宠物,这里就用到了重写的equals方法和hashCode方法
*/
public boolean purchasePets(Pet pet) {
Set<Map.Entry<Pet, Integer>> entry = pets.entrySet();
Iterator it = entry.iterator();
while(it.hasNext()) {
if(it.next().equals(pet)) {//如果商店已经包含此宠物，只需更新此宠物的数量
pets.put(pet, pets.get(pet)+pet.getNum());
return true;
}
}
pets.put(pet, pet.getNum());
return true;
}
/**
* 添加宠物,如果已经包含该宠物，则只更改宠物的数量
此功能需要先重写hashCode()和equals()方法
*/
public boolean addPetToShop(Pet pet) {
if(pet == null)
return false;
if(pets.containsKey(pet)) {
pets.put(pet, pets.get(pet)+pet.getNum());
return true;
}else {
pets.put(pet, pet.getNum());
return true;
}
}
/**
* 从商店出售宠物
*/
public boolean removePetFromShop(Pet pet) {
if(pet == null)
return false;
for(Pet p:pets.keySet()) {
if(p.equals(pet) && pets.get(p) == pet.getNum()) {
pets.remove(p);
return true;
}
if(p.equals(pet) && pets.get(p) > pet.getNum()) {
pets.put(pet, pets.get(p) - pet.getNum());
return true;
}
if(p.equals(pet) && pets.get(p) < pet.getNum()) {
return false;
}
}
return false;
}
/**
* 判断是否有顾客前来
* @return
*/
public boolean isHasCustom() {
return isHasCustom;
}
public void setHasCustom(boolean isHasCustom) {
this.isHasCustom = isHasCustom;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public HashMap<Pet,Integer> getPets() {
return pets;
}
}
import java.util.ArrayList;
import java.util.List;
/**
*
* @ClassName: Master
* @Description:主人类，有购买宠物等行为（也就是方法）
*/
public class Master {
private String name;
List<Pet> myPets;
public Master() {
myPets = new ArrayList<Pet>();
}
public Master(String name) {
myPets = new ArrayList<Pet>();
this.name = name;
}
//去宠物店的行为
public boolean goPetShop(PetShop shop) {
shop.setHasCustom(true);
return true;
}
//浏览宠物行为
public void scanPet(PetShop shop) {
if(goPetShop(shop)) {
shop.showAllPet();
}else {
System.out.println("暂时无法浏览宠物！");
}
}
//离开商店的行为
public void outShop(PetShop shop) {
shop.setHasCustom(false);
}
//更新myPets中的宠物的信息
public boolean updateMyPets(Pet pet) {
for(int i = 0;i < myPets.size();i++) {
if(myPets.get(i).equals(pet)) {
myPets.get(i).setName(pet.getName());
myPets.get(i).setNum(pet.getNum());
myPets.get(i).setLoveNum(pet.getLoveNum());
return true;
}
}
return false;
}
//给宠物命名并更新宠物
public boolean setNameToPet(Pet pet,String name) {
if(pet != null && name != null) {
pet = getPetStrain(pet);//获取宠物的种类
pet.setName(name);//如果是Dog类，就执行Dog类的方法
pet.setLoveNum(50);
updateMyPets(pet);
return true;
}
return false;
}
//购买宠物
public boolean buyPet(Pet pet,PetShop shop) {
if(pet != null) {
pet.setNum(1);
myPets.add(pet);
shop.removePetFromShop(pet);//这里宠物商店里的宠物要减少一只
return true;
}
else
return false;
}
/**
* 给宠物喂食
*/
public boolean feedPet(Pet pet) {
if(pet!= null) {
getPetStrain(pet).eat();
return true;
}
return false;
}
//查看所拥有的宠物信息
public boolean scanMyPets() {
if(myPets.size()==0) {
return false;
}
System.out.println("id\t品种\t名字\t亲密值");
for(Pet p:myPets) {
System.out.print(p.getId()+"\t"+p.getStrain()+"\t"+p.getName()
+"\t"+p.getLoveNum()+"\n");
}
return true;
}
//查看某个宠物的亲密值
public void loveNumWithPet(String name) {
Pet pet = getMyPetByName(name);
System.out.println(pet.getName() + "：我们的亲密值为"+pet.getLoveNum());
}
//通过名字查找宠物
public Pet getMyPetByName(String petName) {
for(Pet pet:myPets) {
if(pet.getName().equals(petName)) {
return pet;
}
}
return null;
}
//获取宠物的品种
public Pet getPetStrain(Pet pet) {
if(pet.getStrain().equals("波斯猫")||pet.getStrain().equals("加菲猫")) {
return((Cat)(pet));
}
if(pet.getStrain().equals("哈士奇")||pet.getStrain().equals("中华田园犬")) {
return((Dog)(pet));
}
return null;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Pet> getMyPets() {
return myPets;
}
public void setMyPets(List<Pet> myPets) {
this.myPets = myPets;
}
}
import java.util.ArrayList;
import java.util.List;
/**
*
* @ClassName: Master
* @Description:主人类，有购买宠物等行为（也就是方法）
* @author yemao
* @date 2019年3月21日
*/
public class Master {
private String name;
List<Pet> myPets;
public Master() {
myPets = new ArrayList<Pet>();
}
public Master(String name) {
myPets = new ArrayList<Pet>();
this.name = name;
}
//去宠物店的行为
public boolean goPetShop(PetShop shop) {
shop.setHasCustom(true);
return true;
}
//浏览宠物行为
public void scanPet(PetShop shop) {
if(goPetShop(shop)) {
shop.showAllPet();
}else {
System.out.println("暂时无法浏览宠物！");
}
}
//离开商店的行为
public void outShop(PetShop shop) {
shop.setHasCustom(false);
}
//更新myPets中的宠物的信息
public boolean updateMyPets(Pet pet) {
for(int i = 0;i < myPets.size();i++) {
if(myPets.get(i).equals(pet)) {
myPets.get(i).setName(pet.getName());
myPets.get(i).setNum(pet.getNum());
myPets.get(i).setLoveNum(pet.getLoveNum());
return true;
}
}
return false;
}
//给宠物命名并更新宠物
public boolean setNameToPet(Pet pet,String name) {
if(pet != null && name != null) {
pet = getPetStrain(pet);//获取宠物的种类
pet.setName(name);//如果是Dog类，就执行Dog类的方法
pet.setLoveNum(50);
updateMyPets(pet);
return true;
}
return false;
}
//购买宠物
public boolean buyPet(Pet pet,PetShop shop) {
if(pet != null) {
pet.setNum(1);
myPets.add(pet);
shop.removePetFromShop(pet);//这里宠物商店里的宠物要减少一只
return true;
}
else
return false;
}
/**
* 给宠物喂食
*/
public boolean feedPet(Pet pet) {
if(pet!= null) {
getPetStrain(pet).eat();
return true;
}
return false;
}
//陪宠物玩耍
public boolean playWithPet(Pet pet) {
if(pet!= null) {
getPetStrain(pet).play();
return true;
}
return false;
}
//查看所拥有的宠物信息
public boolean scanMyPets() {
if(myPets.size()==0) {
return false;
}
System.out.println("id\t品种\t名字\t亲密值");
for(Pet p:myPets) {
System.out.print(p.getId()+"\t"+p.getStrain()+"\t"+p.getName()
+"\t"+p.getLoveNum()+"\n");
}
return true;
}
//查看某个宠物的亲密值
public void loveNumWithPet(String name) {
Pet pet = getMyPetByName(name);
System.out.println(pet.getName() + "：我们的亲密值为"+pet.getLoveNum());
}
//通过名字查找宠物
public Pet getMyPetByName(String petName) {
for(Pet pet:myPets) {
if(pet.getName().equals(petName)) {
return pet;
}
}
return null;
}
//获取宠物的品种
public Pet getPetStrain(Pet pet) {
if(pet.getStrain().equals("波斯猫")||pet.getStrain().equals("加菲猫")) {
return((Cat)(pet));
}
if(pet.getStrain().equals("哈士奇")||pet.getStrain().equals("中华田园犬")) {
return((Dog)(pet));
}
return null;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Pet> getMyPets() {
return myPets;
}
public void setMyPets(List<Pet> myPets) {
this.myPets = myPets;
}
}
import java.util.Scanner;
/**
* @ClassName: Test
* @Description: 测试类
* ArrayList在遍历的时候如果同时删除元素就会抛出java.util.ConcurrentModificationException异常
*/
public class Test {
private static Scanner sc = new Scanner(System.in);// 实例化一个输入流对象
public static void main(String[] args) {
PetShop shop = new PetShop();
Master master = new Master("明明");//实例化一个宠物主人，明明
Pet pet = null;
int circleNum = 0;// 表示while循环的次数
int choiceNum = -1;// 操作数
String petId = "";
while(choiceNum == -1) {
circleNum++;
if(circleNum == 1) {
System.out.println("**进购宠物**");
new Pet();//初始化进购的宠物种类，为的是执行Pet.java里的静态代码块
}
System.out.println("选择操作：1、进购\t2、离开");
choiceNum = sc.nextInt();
if(choiceNum == 1) {
System.out.println("请输入要进购宠物的id和数量");
pet = Pet.givePetToShop(sc.next(), sc.nextInt());
if(pet != null) {
shop.addPetToShop(pet);//商家进购此宠物
System.out.println("进购成功！");
choiceNum = -1;
}else {//表示输入的id有误，没有此类宠物
System.out.println("没有此类宠物！");
choiceNum = -1;
}
}else if(choiceNum == 2) {
choiceNum = -2;
}else {
System.out.println("输入有误！请重新选择！");
}
}
circleNum = 0;
master.goPetShop(shop);// 去宠物店
while (shop.isHasCustom()) {
circleNum++;
if (circleNum == 1) {
System.out.println(shop.getName() + ":欢迎" + master.getName() + "光临本店");
} else {
System.out.println(shop.getName() + ":请选择要进行的操作:1.浏览宠物\t2.离开本店");choiceNum = sc.nextInt();// 从键盘控制台接收一个整数
if (choiceNum == 1) {
master.scanPet(shop);// 明明浏览宠物
System.out.println(shop.getName() + ":请输入编号来选择您想要的宠物：");
petId = sc.next();
pet = shop.getPetById(petId);// 通过id获得宠物
if (pet == null) {
System.out.println(shop.getName() + "：请输入正确的编号！");
} else {
System.out.println(shop.getName() + ":您选择了" + pet + ",是否确认购买？1.确认购买\t2.在考虑一下");
choiceNum = sc.nextInt();
if (choiceNum == 1) {
master.buyPet(pet, shop);// 明明购买这个宠物
System.out.println(shop.getName() + "：恭喜您获得新宠！");
}
}
} else if (choiceNum == 2) {
master.outShop(shop);// 离开商店
System.out.println(shop.getName() + ":客官慢走，欢赢下次光临！");
circleNum = 0;
}
}
}
System.out.println(master.getName()+ "离开了" + shop.getName() + "宠物店，正在回家的路上.......");
String petName = null;
while (true) {
circleNum++;
if (circleNum == 1) {
System.out.println(master.getName() + "回到家了");
System.out.println(master.getName() + ":给新买的宠物们起个名吧！嘻嘻！");
for (Pet p : master.getMyPets()) {
System.out.println("这只宠物是" + p.getStrain() + ",给他起个名字：");
petName = sc.next();
if (master.setNameToPet(pet, petName)) {// 给宠物起名字
System.out.println(pet.getName() + ":有了新名字很开心！亲密值增加了" + pet.getLoveNum());
}
}
System.out.println(master.getName() + ":所有的宠物都起好名字了，他们更喜欢我了！");
System.out.println("请选择操作:1.给宠物喂食\t" +"2.获取所有的宠物信息\t3.退出：");
choiceNum = sc.nextInt();
}
if (choiceNum > 4 || choiceNum < 1) {
System.out.println("输入有误！");
} else {
while (choiceNum == 1) {
System.out.println(master.getName() + ":先喂给谁呢？随便点名吧！");
pet = master.getMyPetByName(sc.next());
master.feedPet(pet); System.out.println("请选择操作:1.给宠物喂食\t" +"2.获取所有的宠物信息\t3.退出：");
choiceNum = sc.nextInt();
}
while (choiceNum == 2) {
master.scanMyPets();
System.out.println("请选择操作:1.给宠物喂食\t" +"2.获取所有的宠物信息\t3.退出：");
choiceNum = sc.nextInt();
}
if (choiceNum ==3)
break;
}
}
System.out.println("程序已退出！");
}
}
感谢各位的阅读，以上就是“java面向对象编程的方法是什么”的内容了，经过本文的学习后，相信大家对java面向对象编程的方法是什么这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是亿速云，小编将为大家推送更多相关知识点的文章，欢迎关注！