类的封装
封装的载体是类，且对象的属性和行为被封装在这个类中。
例：通过封装性封装厨师的具体信息，厨师只负责烹饪，所有的服务均有服务员来完成。
package unit1;
public class Restaurant0 {
private Cook cook=new Cook();
public String waitername="David";
public void TakeOrder(String dish) {
cook.cooking(dish);
System.out.println(waitername+":菜好了，请慢用！");
}
public String SaySorry() {
return "抱歉，本店不提供此服务";
}
class Cook{
private String name;
public Cook() {
this.name="Tommy";
}
private void CutOnion() {
System.out.println(name+"开始切洋葱");
}
private void WashVegetables() {
System.out.println(name+"开始洗蔬菜");
}
void cooking(String dish) {
CutOnion();
WashVegetables();
System.out.println(name+"开始烹饪"+dish);
}
}
public static void main(String args[]) {
Restaurant0 waiter=new Restaurant0();
System.out.println("请为我做一个鱼香肉丝");
waiter.TakeOrder("鱼香肉丝");
System.out.println("请告诉我你们厨师的名字");
System.out.println(waiter.SaySorry());
}
}
类的继承
在JAVA中让子类继承父类需要使用extends关键字，语法如下：
Child extends Parents
子类在继承了父类的同时，也继承了父类的属性与方法，且一个类只能继承一个父类，也可以在子类中扩展自己的方法甚至直接重写父类中的某些方法。
例：使用继承方法继承父类属性，并添加自己的属性
package unit1;
public class Computer {
String screen="液晶显示屏";
void startup() {
System.out.println("电脑正在开机，请稍等");
}
public static class Pad extends Computer{
String battery="5000毫安电池";
public static void main(String args[]) {
Computer pc=new Computer();
System.out.println("computer的屏幕是："+pc.screen);
pc.startup();
Pad ipad=new Pad();
System.out.println("ipad的屏幕是："+ipad.screen);
System.out.println("ipad的电池容量是："+ipad.battery);
ipad.startup();
}
}
}
注意：将主函数放在继承的子类中时，继承子类需加上static属性，使其供全局所有。
方法的重写
父类的所有成员都会被子类继承，当父类中的某个方法并不适用于子类时，就需要在子类中重写父类的这个方法。
重构：特殊的重写方式，子类与父类的成员方法返回值、方法名称、参数类型及个数完全相同，唯一不同的是方法的实现内容。
注意：重写父类的方法时，只能从小的范围到大的范围改变，例如父类方法中是private，子类继承重写只能将其改为public或者不变。
例：方法的重写
package unit1;
public class Computer2 {
void ShowPicture() {
System.out.println("鼠标点击！");
}
public static class Pad2 extends Computer2 {
void ShowPicture() {
System.out.println("手指点击触摸屏！");
}
public static void main(String args[]) {
Computer2 pc=new Computer2();
System.out.println("pc打开图片：");
pc.ShowPicture();
Pad2 ipad=new Pad2();
System.out.println("iPad打开图片：");
ipad.ShowPicture();
}
}
}
super关键字
如果子类重写了父类的方法，想在子类方法中实现父类原有的方法，使用super关键字可以完成操作，语法格式：
super.property; //调用父类的属性
super.method(); //调用父类的方法
所有类的父类Object类
在JAVA中所有的类都直接或间接继承了java.lang.Object 类
getClass方法：会返回某个对象执行时刻的Class实例，然后通过Class实例调用getName()方法获取类的名称，getClass().getName();
toString()方法：本方法会返回某个对象的字符串表达形式
类的多态性
多态性的定义是一种定义，多种实现，例如，运算符+作用于两个整形的中间是求和，作用于两个字符串之间是连接作用。类的多态性体现在两方面，第一：方法的重载，第二：类的上下转型.
方法的重载
构造方法的名称由类名决定，如果以不同的方式创建某个类的对象，就需要使用多个形参不同的构造方法来完成，这些方法名称相同但形参不同。
例：使用重载对不同形参进行操作
package unit1;
public class OverLoadTest {
public static int add(int a) {
return a;
}
public static int add(int a,int b) {
return a+b;
}
public static double add(double a,double b) {
return a+b;
}
public static int add(int a,double b) {
return (int)(a+b);
}
public static int add(double a,int b) {
return (int)(a+b);
}
public static void main(String args[]) {
System.out.println("调用add(int):"+add(1));
System.out.println("add(int,int):"+add(1,2));
System.out.println("add(double,double):"+add(2.1,3.3));
System.out.println("add(int,double):"+add(1,3.3));
System.out.println("add(double,int):"+add(2.1,3));
}
}
向上转型
在JAVA中，对象类型的转换包括向上转型和向下转型，例如平行四边形是特殊的四边形，也就是说平行四边形是四边形的一种，那么就可以将平行四边形对象看作是一个四边形对象，即在子类中可以安全调用父类的方法。
例如：使用向上转型，使子类继承父类，然后在主函数中调用父类方法
package unit1;
public class Quadrangle {
public static void draw(Quadrangle q) {
System.out.println("绘画一个图形");
}
public static class Parallelogram extends Quadrangle{
public static void main(String args[]) {
Parallelogram p=new Parallelogram();
draw(p);
}
}
}
抽象类与抽象方法
把类似无法使用具体语言定义的图形类称为抽象类，在JAVA中，抽象类不能产生实例对象，语法格式如下：
abstract class 类名{
类体；
}
使用abstract修饰的方法称之为抽象方法，定义格式如下：
[权限修饰符] abstract 方法返回值类型 方法名（参数列表）；
抽象方法必须承载到抽象类中去，而抽象类存在的唯一作用就是被继承，在子类中重写对应的抽象方法。
例如，在抽象类中进行如下操作：
package unit1;
public abstract class Market {
public String name;
public String goods;
public abstract void shop();
}package unit1;
public class TaobaoMarket extends Market {
@Override
public void shop() {
// TODO Auto-generated method stub
System.out.println(name+"网购"+goods);
}
}package unit1;
public class WallMarket extends Market {
@Override
public void shop() {
// TODO Auto-generated method stub
System.out.println(name+"实体店购买"+goods);
}}
package unit1;
public class GoShopping {
public static void main(String args[]) {
Market market=new WallMarket();
market.name="沃尔玛";
market.goods="七匹狼";
market.shop();
market=new TaobaoMarket();
market.name="淘宝";
market.goods="短袖";
market.shop();
}
}
接口的声明及实现
接口是抽象的延申，可以将它看作是抽象类，接口中的所有方法都没有方法体，都是抽象方法等待继承，接口只可以继承接口，当几个不同类的类想完成共同的操作实现多态性时，需要定义接口，在各个类中实现接口，在主函数中调用接口，传递相应的参数，实现多态性，语法格式：
[修饰符] interface 接口名 [extends 父接口名列表]{
[public] [static][final]常量；
[public] [abstract] 方法;
}
多重继承
使用接口可以实现多重继承
语法格式：
ass 类名 implements 接口1，接口2，接口3
final关键字
被final关键字修饰的类、方法、变量不能被改变，被其修饰的类不能被继承，并且不允许任何人对此类进行改动，被其修饰的方法不能被重写。
成员内部类与匿名内部类
在一个类中除了定义成员变量与方法外还可以定义一个内部类，例如在汽车类中可以定义一个发动机类。
匿名内部类特点是只需要使用一次，匿名内部类不能被重复使用，创建完一次实例后立即销毁掉。
new A(){
...;
}
