|
封装 ：属性设置为private的，封装再类的内部，对外提供public的get/set方法供外部调用。
在类的内部对参数做一些限制，防止非法的调用 继承：使用extends 关键词，继承父类的属性和方法，不继承构造方法。
没有显式写extends时，默认是从Object继承的
每个类只能有一个父类，但是可以有多层继承。比如一个有父类，祖父类，曾祖父类...
子类除了继承父类的属性和方法，也可以有自己的属性和方法。
重写override 重载 overload的差别
重写：子类重写父类同名的方法。
重载： package day04;
/*
圆的类：
属性：r
方法：构造方法 get/set方法，zhouchang。mianji
圆柱的类从圆类继承
属性：h
方法：构造方法，get/set方法，mianji（重写父类的同名方法），tiji（子类特有的）
*/ import com.sun.org.apache.bcel.internal.generic.GETFIELD;
public class Demo03 {
public static void main(String[] args) {
Circle c1 = new Circle(1);
System.out.println(c1);
System.out.println( "面积：" + c1.mianJi() + ",周长：" + c1.zhouChang());
Cylinder c2 = new Cylinder(2,4);
System.out.println(c2);
System.out.println( "面积：" + c2.biaoMian() + ",体积：" + c2.tiJi());
}
}
class Circle {
private float r;
public Circle(float r) {
this.r = r;
}
@Override
public String toString() {
return "Circle{" +
"r=" + r +
'}';
}
public float getR() {
return r;
}
public void setR(float r) {
this.r = r;
}
public double mianJi() {
return r * r * Math.PI;
}
public double zhouChang () {
return 2 * r * Math.PI;
}
}
class Cylinder extends Circle {
private float h;
public Cylinder(float r) {
super(r);
}
public Cylinder(float r, float h) {
super(r);
this.h = h;
}
public float getH() {
return h;
}
public void setH(float h) {
this.h = h;
}
public double biaoMian(){
return 2*super.mianJi()+super.zhouChang()* getH();
}
public double tiJi(){
return super.mianJi()*getH();
}
@Override
public String toString() {
return "Cylinder{" +
"h=" + h +
"}"
+ super.toString();
}
} 多态： 子类的对象可以当作父类的对象来使用
Dog. Pet，Dog的对象，既有Dog类型的，也是Pet 类型的
Pet的对象，有可能是Dog，有可能是Cat public class Demo04 {
// 宠物看病的方法
public static void doctor(Dog dog) {//传Dog 以及Dog的子类
if (dog.getHealth()<50){
System.out.println("打针");
dog.setHealth((dog.getHealth() +10));
}else{
System.out.println("按摩");
dog.setHealth((dog.getHealth() +2));
}
}
public static void doctor_shenyi(Pet pet) { // 传pet或者pet的子类都可以
if (pet.getHealth() < 50) {
System.out.println("打针");
pet.setHealth((pet.getHealth() + 10));
} else {
System.out.println("按摩");
pet.setHealth((pet.getHealth() + 2));
}
}
public static void main(String[] args) {
Dog dog = new Dog("阿黄",3,40);
doctor(dog);
doctor(dog);
doctor(dog);
doctor(dog);
doctor_shenyi(dog);//方法定义的是Pet类型的参数，实际传的是Dog类型的参数。
System.out.println(dog.getHealth());
Pet pet = new Pet("阿华",2,50);
// doctor(pet); // 父类的对象不能当做子类来使用
doctor_shenyi(pet);
Cat cat = new Cat("加菲",1,80);
doctor_shenyi(cat);
TaiDi taiDi = new TaiDi("泰迪",2,60,"黑色");
doctor_shenyi((taiDi));
doctor(taiDi);
}
}
class Cat extends Pet{
public Cat(String name, int age, int health) {
super(name, age, health);
}
}
class TaiDi extends Dog{
public TaiDi(String name, int age, int health, String color) {
super(name, age, health);
}
} 抽象类：abstract 修饰
1.有抽象方法的类是抽象类,抽象方法只有声明，没有实现
2.抽象类中既有抽象方法，又可以有普通方法。
3.抽象类无法实例化。无法new一个对象。
4.抽象类主要是为了被继承，子类必须实现里面的抽象方法。
如果子类不实现抽象方法，子类也只能定义成抽象类 接口：interface，特殊的抽象类
1.接口中的方法都是抽象的方法，没有的普通的方法。方法默认都是 public abstract 修饰的
2.接口中的成员变量，都是常量。默认是用 public static final修饰的。 接口中不能又构造方法。
接口可以采用多继承的机制，一个类可以实现多个接口。
final 关键字
修饰类：类不能被继承
修饰方法：不能子类重写
修饰成员变量：只能被赋值一次，不能修改
修饰局部变量：只能被赋值一次，不能修改 static 静态
修饰成员变量：static修饰后，用类名，变量 调用
修饰方法 class Voter{
String name ; //选民的名字，每个实例特有的属性。用实例.name
static int count; // 所有选民共有的，属于类的。用类名.方法名 ststic修饰成员变量；
| 
