**chp6 三大特性
封装 继承 多态
1、封装:**
对象的边界对对象的内部起到保护的作用:
数据隐藏
public 公开的 不受边界的约束
private 私有 只能在本类内部访问 无法突破边界
属性私有 提供公开的setXXX/getXXX用来访问属性
方法私有 只给自己调用
方法公开:声明公开 实现隐藏
实现的改变对架构的影响最小
数据左移一位与数据*2是一样的
a*2 a<<1
package chp6;
public class TestEncapsulation{
public static void main(String[] args){
CreditCard card=new CreditCard();
System.out.println(card.getPassword());
//card.password="1234";
card.setPassword("1234");
//card.password="1234";
//card.password="654321";
System.out.println(card.getPassword());
}
}
class CreditCard{
private String password="123456";
public String getPassword(){
return password;
}
public void setPassword(String password){
if(password.length()!=6)return;
this.password=password;
}
}
2、继承
父类–子类 一般–特殊 父类:子类的共性抽象出来
动物 狗 猫
关键字 extends
创建子类对象要首先创建父类对象。
父类对象包含在子类对象当中。
所有的子类能够访问的父类属性和方法,即是子类从父类中继承的属性和方法。
从严到宽
private 私有 本类内部 不能继承
(default) 本类+同包 同包子类可以继承
protected 受保护的 本类+同包+不同包的子类 可以继承
public 公开 可以继承
构造方法不能继承
方法的覆盖(Override)
子类用特殊的方法实现替换父类继承给它的一般的方法实现。
返回值类型 方法名 参数表 访问修饰符相同或更宽。
3、多态
多态:
子类的对象可以看作是父类的对象
子类对象可以放入父类引用
1)对象类型不变
2)只能对引用调用其引用类型中声明的方法
3)运行时,根据对象实际类型找子类覆盖之后的方法
子类引用赋值给父类引用 可以直接赋值
父类引用赋值给子类引用 必须强制类型转换
运行时可能发生类型转换异常
在做强制类型之前,可以用instanceof判断, 避免类型转换异常。
package chp6;
public class TestPolymorphism{
public static void main(String[] args){
Animal a=new Dog();
System.out.println(a instanceof Dog);
System.out.println(a instanceof Cat);
System.out.println(a instanceof Animal);
a.eat();
a.sleep();
if(a instanceof Dog){
Dog d=(Dog)a;
d.shot();
}
}
}
class Animal{
public Animal(){}
public void eat(){
System.out.println("Animal.eat()");
}
public void sleep(){
System.out.println("6 hours");
}
}
class Dog extends Animal{
public Dog(){}
public void eat(){
System.out.println("Dog.eat()");
}
public void sleep(){
System.out.println("8 hours");
}
}
class Cat extends Animal{
public Cat(){}
public void eat(){
System.out.println("Cat.eat()");
}
public void sleep(){
System.out.println("8 hours");
}
}
多态的作用:
将不同的子类对象统一看作父类对象,就屏弊了不同子类的差异
package chp6;
public class TestPloy2{
public static void main(String[] args){
Animal[] a=new Animal[10];
a[0]=new Dog();
a[1]=new Cat();
a[2]=new Tiger();
a[3]=new Sheep();
a[4]=new Wolf();
a[5]=new Snake();
a[6]=new Mouse();
a[7]=new Cock();
a[8]=new YellowMouseWolf();
a[9]=new Monkey();
for(int i=0;i<a.length;i++){
a[i].eat();
}
/*Dog a0=new Dog();
Cat a1=new Cat();
Tiger a2=new Tiger();
Sheep a3=new Sheep();
Wolf a4=new Wolf();
Mouse a5=new Mouse();
Snake a6=new Snake();
Monkey a7=new Monkey();
Cock a8=new Cock();
YellowMouseWolf a9=new YellowMouseWolf();
a0.eat();
a1.eat();
a2.eat();
a3.eat();
a4.eat();
a5.eat();
a6.eat();
a7.eat();
a8.eat();
a9.eat();*/
}
}
class Animal{
public void eat(){
}
}
class Dog extends Animal{
public void eat(){
System.out.println("Dog eat bone");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("Cat eat fish");
}
}
class Tiger extends Animal{
public void eat(){
System.out.println("Tiger eat human");
}
}
class Sheep extends Animal{
public void eat(){
System.out.println("Sheep eat grass");
}
}
class Wolf extends Animal{
public void eat(){
System.out.println("Wolf eat Sheep");
}
}
class Mouse extends Animal{
public void eat(){
System.out.println("Mouse eat rice");
}
}
class Snake extends Animal{
public void eat(){
System.out.println("Snake eat mouse");
}
}
class Monkey extends Animal{
public void eat(){
System.out.println("Monkey eat banner");
}
}
class Cock extends Animal{
public void eat(){
System.out.println("Cock eat rice");
}
}
class YellowMouseWolf extends Animal{
public void eat(){
System.out.println("YellowMouseWolf eat Cock");
}
}
多态的常见用法
Animal a=new Dog();
1)多态用在方法参数上 形参可以是父类引用,实参可以传子类对象
m(A a):可以用A的任何子类对象作为参数
2)多态用在方法的返回值上
A m():m方法完全可以返回A的某个子类对象
package chp6;
public class TestPoly3{
public static void main(String[] args){
Dog d=new Dog();
m1(d);
Cat c=new Cat();
m1(c);
Animal a1=m2(10);
}
ststic void m1(Animal a){
}
ststic Animal m2(int k){
if(k%2==0)return new Dog();
else return new Cat();
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}