JAVA 面向对象（六）

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

1. JAVA中的访问修饰符

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

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

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

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

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

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

---

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

访问修饰符	本类	本类包其他类（子类）	其他包	其他包 子类
public（公共的）	√	√	√	√
private（私有的）	√	×	×	×
default（缺省的 默认的）	√	√	×	×
protected （受保护的）	√	√	×	√

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

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

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

• default (缺省的)：

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

---

2. 多态 ★★★

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

• 多态在程序设计中，为程序提供了 [可插拔性]。

• 你记得，子类赋值给父类。自动类型转换。向上转型。

• 你记得，父类强制转换成子类，需要加子类类型符号，向下转型。

2. 多态：形成的必要因素：
   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到！！！