先说说封装：
用new 一条狗来举个例子:
public class Dog {
//私有化字段
private String name;
private int age;
//无参构造
Dog(){
}
//带参构造
Dog(String name,int age){
this.name = name;
this.age = age;
}
//setter and getter 方法
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;
}
}
私有化成员变量后就不能直接使用 object.name 的形式改变字段值了。可以使用构造函数初始化字段值或者使用getter setter方法获取、改变字段值。
public class MyMain {
public static void main(String[] args) {
Dog dog = new Dog("旺旺", 3);//创建Dog对象并初始化dog:旺旺，3
Dog dog2 = new Dog();
dog2.setName("张三");//使用setter方法
dog2.setAge(15);//dog2:张三，15
}
}
然后是继承：
父类是Pet 类：
public abstract class Pet {
private String name;
private int age;
public Pet(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Pet(){
print();//虽然编译不报错,但是最好不要这么写,父类构造中调用可被子类覆盖的方法破坏封装
}
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 abstract void print();//抽象类可以有抽象方法和非抽象方法,但是非抽象类不能有抽象方法;抽象方法不是类方法,不能用static修饰
abstract int calc(int i) throws ArithmeticException;//测试子类抛出异常范围
}
子类是Penguin 类：
public class Penguin extends Pet{
private int love;
public Penguin(String name, int age, int love) {
super(name, age);
this.love = love;
}
public Penguin(){
super();
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
@Override//方法名相同,参数列表相同,返回值类型相同
public void print() {//子类重写父类方法不能减少其访问权限,这里使用非public会报错
//原因:父类引用指向子类对象,如果子类方法访问权限少,那么将会导致方法调用者可调用父类方法却不能调用子类的重写方法.
// TODO Auto-generated method stub
System.out.println("我是:"+this.getName()+"年龄:"+this.getAge()+"健康值"+this.getLove());
}
@Override
int calc(int i) throws ArithmeticException{//子类重写父类方法不能抛出更多的异常,这里抛出Exception或其他异常会报错
//原因:父类引用指向子类对象,如果子类抛出更多的异常,那么将会导致方法调用者try-catch父类异常时忽略了子类更多的异常(catch不到)
// TODO Auto-generated method stub
return 1/i;
}
}
测试类：
public class MyMain {
public static void main(String[] args) {
Pet penguin = new Penguin();//父类变量 指向 子类对象,父类引用 指向 子类对象;向上转型(子类转父类)
penguin.setName("张三");
penguin.setAge(18);
penguin.print();//多态
//penguin.setLove(100);报错,只能调用父类方法表中的方法
Penguin p = (Penguin)penguin;//向下转型(父类转子类)
p.setLove(100);
penguin = (Pet)p;//向上转型
penguin.print();
p = (Penguin)penguin;//向下转型
p.print();
penguin = new Penguin("小企鹅", 6, 100);
penguin.print();
int t;
try {
t = penguin.calc(0);
System.out.println(t);
} catch (ArithmeticException e) {
// TODO Auto-generated catch block
//e.printStackTrace();
System.out.println("除数不能是0!");
}
System.out.println("end ..");
}
}
最后说说多态，
上面代码第4行Pet penguin = new Penguin();已经体现了多态，再写个多态的典型例子——主人给宠物喂食：
public class MyMain {
public static void main(String[] args) {
Pet dog = new Dog();
Pet cat = new Cat();
Person.feeding(dog);
Person.feeding(cat);
}
}
public abstract class Pet {
public abstract void eat();
}
public class Dog extends Pet {
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("够吃骨头...");
}
}
public class Cat extends Pet {
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("猫吃鱼...");
}
}
public class Person {
public static void feeding(Pet pet) {
// TODO Auto-generated method stub
pet.eat();
}
}
附上思维导图: