面向对象编程核心（2）
一.抽象类
1.概述
一个没有方法体的方法应该被定义为抽象方法，而类中如果有抽象方法，则类为抽象类。
public abstratc class Animal{
public abstract void eat(){
}
} 2.抽象类的特点
1)抽象类和抽象方法必须用abstract修饰。
2）抽象类中不一定有抽象方法，但抽象方法一定在抽象类中。
3）抽象类不能实例化，只能通过子类实例化（类似向上转型）
public abstratc class Animal{
public abstract void eat(){
}
}
public class Cat extends Animal{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
}
public class AnimalDemo{
public static void main(String[] args){
Animal a = new Cat();
a.eat();
}
}4)抽象类的子类要么是抽象类，要么重写抽象类中所有的方法
public abstratc class Animal{
public abstract void eat(){
}
public abstract void sleep(){
}
}
public class Cat extends Animal{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
public void sleep(){
System.out.println("猫睡觉");
}
}
或：
public class abstract Cat extends Animal{
}5)抽象类的构造方法和成员方法
有构造方法，但不能实例化，用于子类访问父类数据的初始化。而成员方法有抽象方法，主要用于规定子类方法必须完成的动作，也有非抽象方法，用于提高代码复用性。
二.接口
1.概述
接口是一种公共的规范标准，只要符合标准，大家可以通用。Java的接口更多体现在对行为的抽象。
2.接口的特点
1）接口用关键字interface修饰
2）类实现接口用implements表示,同时接口中的方法都为抽象方法(void show() = public abstract void show())
public class 类名 implements 接口名 {}3)接口直接不能实现化，方法与多态相似
public interface Eat{
public abstract void eat(){
}
}
public class Cat implements Eat{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
}
public class EatDemo{
public static void main(String[] args){
Animal a = new Cat();
a.eat();
}
}4）接口的实现类要么是抽象类，要么重写接口中所有的方法
public interface Eat{
public abstract void eat(){
}
public abstract void sleep(){
}
}
public class Cat implements Eat{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
public void sleep(){
System.out.println("猫睡觉");
}
}
或：
public class abstract Cat implements Eat{
}3.接口的成员变量和构造方法
成员变量只能为常量（默认修饰符：public static final)，没有构造方法。
4.类和接口的关系
public class InterImpl extends Object implements Inter1,Inter2,Inter3{
}
public interface Inter3 extends Inter1,Inter2{
}5.抽象类和接口的区别
public interface Alarm{
//接口中默认为public abstract void alarm()
void alarm();
}
public abstract class door{
public abstract void open();
public abstract void close();
}
public class AlarmDoor extends door implements Alarm{
public void alarm(){
//...
}
public void close(){
//...
}
public void open(){
//...
}
}
在开发中，抽象类更多是对事物的抽象，接口是对行为的抽象。6.抽象类和接口作为形参和返回值
1）抽象类：
public interface Jumping{
void jump(){
}
}
public class Cat implements Jumping{
@Override
public void jump(){
System.out.println("猫跳高");
}
}
public class JumpingOperator{
//方法的形参是接口名，其实需要的是该接口的实现类对象
public void useJumping(Jumping j){
j.jump();
}
//方法的返回值是接口名，其实返回的是该接口的实现类对象
public Jumping getJumping(){
Jumping j = new Cat();
return j;
}
public class JumpingDemo{
public static void main(String[] args){
JumpingOperator jo = new JumpingOperator();
Jumping j = new Cat();
//JumpingOperator中相当于Jumping jo = new Cat();
jo.useJumping(j);
//相当于Jumping j2 = new Cat()
Jumping j2 = ao.getJumping();
a2.jump();
}
}2）接口：
public abstract class Animal{
public abstract void eat(){
}
}
public class Cat extends Animal{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
}
public class AnimalOperator{
//方法的形参是抽象类名，其实需要的是该抽象类的子类对象
public class useAnimal(Animal a){
a.eat();
}
//方法的返回值是抽象类名，其实返回的是该抽象类的子类对象
public Animal getAnimal(){
Animal a = new Cat();
return a;
}
public class AnimalDemo{
public static void main(String[] args){
AnimalOperator ao = new AnimalOperator();
Animal a = new Cat();
//AnimalOperator中相当于Animal a = new Cat();
ao.useAnimal(a);
//相当于Animal a2 = new Cat()
Animal a2 = ao.getAnimal();
a2.eat();
}
}三.内部类
1.概述
在一个类中定义一个类，例如在类A中定义类B，B就是内部类
public class Outer{
public class Inner{
}
}2.内部类的访问特点（仅限于内部类和外部类，不涉及外部类以外的类）
1）内部类可以直接访问外部类的成员，包括私有成员
2）外部类要访问内部类的成员，必须创建对象
public class Outer{
private int num = 19;
public class Inner{
public void show(){
System.out.println(num);
}
}
public void method(){
Inner i = new Inner();
i.show();
}
}3)外部类以外的类想访问内部类的对象的对象创建方式
public class Outer{
private int num = 19;
public class Inner{
public void show(){
System.out.println(num);
}
}
public void method(){
Inner i = new Inner();
i.show();
}
}
public class InnerDemo{
public static void main(String[] args){
//创建内部类对象
Outer.Inner oi = new Outer().new Innre();
oi.show();
}
}3.局部内部类
局部内部类在方法里定义的类，外界无法直接使用，需要在方法内部创建对象使用，该类可以直接访问外部类的成员，也可以访问方法内的局部变量
public class Outer{
private int num = 10;
public void method(){
class Inner{
public void show(){
System.out.println(num);
}
}
Inner i = new Inner();
i.show();
}
}
public class OuterDemo{
public static void main(String[] args){
Outer o = new Outer();
o.method();
}
}4.匿名内部类
前提：存在一个类或接口，然后在方法中创建
格式：
new 类名或者接口名（）{
重写方法；
}
new Inter(){
public void show(){
}
}
本质是一个继承了该类或者实现了该接口的子类匿名对象具体实现：
public class Outer{
public void method() {
//new Inter仅仅是一个对象，在后面加上.show()才是方法的调用
Inter i = new Inter() {
@Override
public void show() {
System.out.println("匿名内部类");
}
}
i.show();
}
}
public interface Inter{
void show();
}
public class OuterDemo{
public static void main(String[] args){
Outer o = new Outer();
o.method();
}
} Tips：
1）没有构造方法
2）不能用private,public,static,final等词修饰
3）只能使用一次
四.Object类
1.是所有类的父类
class Anything{
....
}
等价于
class Anything extends Object{
....
}2.toString()方法
public String toString()
{
return getClass().getName() + "@" + Integer.toHexString(hashCOde());
}一般使用时会重写，会自动生成（https://jingyan.baidu.com/art...
3.equals（）方法
Object中的equals方法是直接判断this和obj本身的值是否相等，即用来判断调用equals的对象和形参obj所引用的对象是否是同一对象.
public boolean equals(Object obj){
return (this == obj)
}
System.out.println(b1.equals(b2));
System.out.println(b1.equals(b3));
System.out.println(b1.equals("hello"));
输出结果:
true
false
false