JAVA 面向对象（六）

小灰灰 2023-06-09 15:25 43阅读 0赞

### 文章目录 ###

*  1. JAVA中的访问修饰符
 *  2. 多态 ★★★
 *   *  2.1 多态存在的三个必要条件
     *  2.2 向上转型和向下转型
     *   *  3.多态的定义与使用格式
         *  \*\*下面是==多态==演示代码：\*\*
         *   *  4.终章……

| |  
| |  
| |  
| |  
| |  
| |  
| |

# 1. JAVA中的访问修饰符 #

***四种修饰符***  
**1.private**  
private —私有的

表示被修饰的类、属性、方法只允许由此类的对象调用，而不允许其他类、其他包或者子类访问。

**2.default**  
default —当没写任何修饰符时默认

即不加任何访问修饰符，通常称为“默认访问模式“。该模式下，只允许在同一个包中进行访问，不同包或同包的子类均不可访问。

**3.protect**  
介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。  
被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。

**4.public**  
java中访问限制最宽的修饰符，一般称之为“公共的”。  
被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。即被修饰后允许任何类进行访问。

--------------------

**访问修饰符下表**（**方便记忆**） get点哦~

<table> 
 <thead> 
  <tr> 
   <th>访问修饰符</th> 
   <th>本类</th> 
   <th>本类包其他类（子类）</th> 
   <th>其他包</th> 
   <th>其他包 子类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>public</strong>（公共的）</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td><strong>private</strong>（私有的）</td> 
   <td>√</td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
  <tr> 
   <td><strong>default</strong>（缺省的 默认的）</td> 
   <td>√</td> 
   <td>√</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
  <tr> 
   <td><strong>protected</strong> （受保护的）</td> 
   <td>√</td> 
   <td>√</td> 
   <td>×</td> 
   <td>√</td> 
  </tr> 
 </tbody> 
</table>

注释：（**强注解，便于理解**）

*  **public (公有的)**： 项目内所有包，所有类均可以访问
 *  **private（私有的）**：

1.  只有本类可以访问。
2.  除类型创建者和类型的内部方法之外任何人都不能访问该元素。

*  **default (缺省的)**：

1.  只有本包可以访问。
2.  只能在本包中进行访问，在其他包中既是继承关系也无法访问。

--------------------

# 2. 多态 ★★★ #

1.一种类型，多种形态，对象在创建时是父类形态，在使用时是子类形态。

*  多态在程序设计中，为程序提供了 \[可插拔性\]。
 *  **你记得，子类赋值给父类。自动类型转换。向上转型**。
 *  **你记得，父类强制转换成子类，需要加子类类型符号，向下转型**。

1.  ***多态***：**形成的必要因素**：  
    **1**：必须有继承关系。  
    **2**：子类中需有方法的重写。

**关键词：instanceof : 是否包含子类对象**。  
——————————————————————

## 2.1 多态存在的三个必要条件 ##

1.要有继承关系的存在（实现接口也是一种继承关系)

2.要有方法的重写

3.要有父类引用指向子类对象

## 2.2 向上转型和向下转型 ##

1.对象的向上转型，其实就是多态写法：

格式： 父类名称 对象名 = new  子类名称();
    
      含义：右侧创建了一个子类对象，把它当作父类来看待使用。
    
        Animal animal=new Dog();
              创建了一直猫对象，当作动物看待，没有问题。
    
      注意事项：向上转型一定是安全的。从小范围转向了大范围，从小范围的猫，向上转换成为更大范围的动物

2.对象的向下转型，其实就是一个还原的动作：

格式： 子类名称 对象名 =（子类名称） 父类对象；
    
       含义：将子类还原，还原成为本来的子类对象

Dog Dog =(Dog) animal;//本来是狗，向上转型成为动物，还原回来成为本来的狗。  
————————————————

### 3.多态的定义与使用格式 ###

*  父类的引用变量指向子类对象：父类类型 变量名 = new 子类类型（）；  
    变量名.方法名（）；

————————————————

（**以上标注都是要get到的点！！！**）

### **下面是多态演示代码：** ###

下面展示一些 `Test测试类 代码片`。

public class Test {
    
    	public static void main(String[] args) {
    	//初始化对象
    	Penguin penguin = new Penguin("qq",2,85,50,"雌");
    		Dog dog = new Dog("大黄",3,75,85,"黄色");
    	
    	
    	// 多态 一种类型，多种形态。
    	Pet pet = new Penguin("qq",2,85,50,"雌");// 你记得，子类赋值给父类。自动类型转换。向上转型。
    	    pet = new Dog("大黄",3,75,85,"黄色");  // 你记得，子类赋值给父类。自动类型转换。向上转型。
    	    
    	    pet.eat();// 多态的父类，拥有子类的多种形态，子类重写父类的方法。父类对象在调用方法时，运行子类的方法。
    	    
    	    
    	if(pet instanceof Penguin){
    		Penguin pen = (Penguin)pet;// 你记得，父类强制转换成子类，需要加子类类型符号，向下转型。
    		pen.eat();
    	}else if(pet instanceof Dog){
    		Dog dog2 = (Dog)pet;
    		dog2.eat();
    		}
    
    	}
    
    }

下面展示一些 `重写父类方法 代码片`。

public class Dog extends Pet{
    
    private String color;
    
    public String getColor() {
    	return color;
    }
    
    public void setColor(String color) {
    	this.color = color;
    }
    
    public Dog() {
    	super();
    }
    
    public Dog(String name, int age, int health, int love, String color) {
    	super(name, age, health, love);
    	this.color = color;
    }
    
    
    public String toString() {
    	return "宠物名："+getName()+"\t宠物年龄："+getAge()+"\t健康值"+getHealth()+"\t亲密度："+getLove()+"\t颜色："+color;
    
    }
    
    // 重写自父类的方法。
    
    public void eat() {
    	System.out.println("我是狗，我吃骨头");
    	// 健康值加1
    	setHealth(getHealth()+1);
    
    	}
    }

下面展示一些 `特殊属性 重写自Object中的方法 代码片`。

public class Penguin extends Pet{
    
    //特殊属性
    private String sex;
    
    public String getSex() {
    	return sex;
    }
    
    public void estSex(String sex){
    	this.sex = sex;
    }
    public Penguin() {
    	super();
    }
    
    public Penguin(String name, int age, int health, int love, String sex) {
    	super(name, age, health, love);
    	this.sex = sex;
    }
    
    // 重写自Object中的方法。
    
    public String toString(){
    	return "宠物名："+getName()+"\t宠物年龄："+getAge()+"\t健康值："+getHealth()+"\t亲密度："+getLove()+"\t性别："+sex;
    }
    
    //重写自父类的方法。
    public void eat(){
    	System.out.println("我是企鹅，我吃鱼");
    	setHealth(getHealth()+1);
    }
    	
    }

下面展示一些 `父类 代码片`。

public class Pet {
    
    private String name;
    private int age;
    private int health;
    private int love;
    
    public String getName(){
    	return name;
    }
    public void setName(String name){
    	this.name = name;
    }
    public int getAge(){
    	return age;
    }
    public void setAge(int age){
    	this.age = age;
    }
    public int getHealth(){
    	return health;
    }
    public void setHealth(int health){
    	this.health = health;
    }
    public int getLove(){
    	return love;
    }
    public void setLove(int love){
    	this.love = love;
    }
    public Pet(){
    	super();
    }
    public Pet(String name,int age,int health,int love){
    	super();
    	this.name = name;
    	this.age = age;
    	this.health = health;
    	this.love = love;
    }
    
    public void eat(){};
    
    
    }

其中测试类中

Pet pet = new Penguin("qq",2,85,50,"雌");
    	    pet = new Dog("大黄",3,75,85,"黄色");

**如果打印输出需要把上面Dog注释掉，企鹅，狗 两个打印时不能同时出现！！！**

————————————————————

#### 4.终章…… ####

面向对象通过·1~6张博客已经大概介绍完毕，面向对象章节中j的三大基本特征是：  
【封装】、【继承】、【多态】。还有一系列知识点已经都在上面了。

————————————————————

*  **希望有用的可以get到！！！**