面向对象基础知识总结

面向对象的思维：
1、在这个问题内应该有哪些个类、哪些个对象；
2、这些类好对象应该具有哪些个属性和方法；
3、类和类之间具备什么样的关系。

构造方法：
1、使用new + 构造方法创建一个新的对象；
2、构造函数是定义在java类中的一个用来初始化对象的函数；
3、构造函数与类同名且没有返回值；
4、当没有构造函数时，编译器会自动添加默认的构造函数，但一旦指定后编译器不再添加；
5、常犯的错误是在方法名（构造函数名和类名同名）前加void。
 
方法重载：
1、是指一个类中可以定义相同的名字，但参数不同的方法，调用时会根据不同的参数选择对应的方法。
2、重载的方法必须具有不同的参数列表，但是不能基于不同修饰符或返回值类型来重载方法。
3、有时调用一个方法时，会有一个或者多个可能的匹配，编译器无法判断哪个更精确，会产生歧义错误。

继承：
1、子类是extends父类出来的；
2、子类会继承父类所有public、protected类型的实例变量和方法（如果子类和父类在同一package则还继承默认访问      权限的方法和变量），但不会继承父类所有private类型的变量和方法；
3、继承下来的方法可以被覆盖，但实例变量不能被覆盖；
4、使用IS-A 来验证继承结果的合理性，即A extends B 则一定符合A是一个B。

方法的重写：
1、在子类中可以根据需要对父类中继承的方法进行重写；
2、重写方法必须和被重写的方法具有相同的名称，返回类型和参数列表；
3、重写方法不能使用比被重写方法更严格的访问权限，但是可以扩大；
4、如果子类中还打算引用父类的方法然后再加上额外的行为，这就用到了super关键字，可以让子类

1、在这个问题内应该有哪些个类、哪些个对象；
2、这些类好对象应该具有哪些个属性和方法；
3、类和类之间具备什么样的关系。

构造方法：
1、使用new + 构造方法创建一个新的对象；
2、构造函数是定义在java类中的一个用来初始化对象的函数；
3、构造函数与类同名且没有返回值；
4、当没有构造函数时，编译器会自动添加默认的构造函数，但一旦指定后编译器不再添加；
5、常犯的错误是在方法名（构造函数名和类名同名）前加void。
 
方法重载：
1、是指一个类中可以定义相同的名字，但参数不同的方法，调用时会根据不同的参数选择对应的方法。
2、重载的方法必须具有不同的参数列表，但是不能基于不同修饰符或返回值类型来重载方法。
3、有时调用一个方法时，会有一个或者多个可能的匹配，编译器无法判断哪个更精确，会产生歧义错误。

继承：
1、子类是extends父类出来的；
2、子类会继承父类所有public、protected类型的实例变量和方法（如果子类和父类在同一package则还继承默认访问      权限的方法和变量），但不会继承父类所有private类型的变量和方法；
3、继承下来的方法可以被覆盖，但实例变量不能被覆盖；
4、使用IS-A 来验证继承结果的合理性，即A extends B 则一定符合A是一个B。

方法的重写：
1、在子类中可以根据需要对父类中继承的方法进行重写；
2、重写方法必须和被重写的方法具有相同的名称，返回类型和参数列表；
3、重写方法不能使用比被重写方法更严格的访问权限，但是可以扩大；
4、如果子类中还打算引用父类的方法然后再加上额外的行为，这就用到了super关键字，可以让子类 不完全覆盖掉父      类的功能，只是加上额外的行为。

public class Animal{
	public void print() {
		System.out.println("I am father.");
	}
}

class Dog extends Animal {
	public void print(){
		super.print();
		System.out.println("I am son.");
	}

	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.print();
	}
}

运行结果：
I am father.
I am son.

super：
在继承中当子类new出一个对象时，在stack中出现一个变量并指向heap中new出来的对象，在这个对象中会包含
一个父类的对象，并有this、super。this指向这个子类对象的本身，super指向包含着的父类对象。


继承中的构造方法：
1、子类的构造过程中必须调用其基类的构造方法；
2、子类可以在自己的构造方法中使用super调用其基类的构造方法；
使用this调用本类的另外的构造方法；
如果调用super，必须在子类构造方法的第一行；
3、如果子类的构造方法没有显示的调用基类构造方法，则系统默认调用其基类无参数的构造方法；
 public ClassName() {


 }
 等价于
 public ClassName() {
  super();
 }

public class A {
    public A() {
        System.out.println("(1)A");
    }
} 

class B extends A {
	public B() {
		System.out.println("(2)B");
	}
	public static void main(String[] args) {
		new B();
	}
}
运行结果：
(1)A
(2)B

4、如果子类构造方法中既没有显式调用基类构造方法，而基类中又没有无参的构造方法，则编译出错。

public class A {
    public A(String name) {
        System.out.println("(1)A");
    }
} 

class B extends A {
	public B() {
		System.out.println("(2)B");
	}
	public static void main(String[] args) {
		new B();
	}
}

运行结果：
E:\test-git\extends>javac A.java
A.java:9: 错误: 无法将类 A中的构造器 A应用到给定类型;
        public B() {
                   ^
  需要: String
  找到: 没有参数
  原因: 实际参数列表和形式参数列表长度不同
1 个错误

5、构造方法可用来构造一个类的实例。不像属性和方法，父类的构造方法时不被子类继承的，他们只能
从子类的构造方法中通过super调用。

public class A {
    public A(String name) {
        System.out.println(name);
    }
} 

class B extends A {
	public B() {
		this("(2)B");
		System.out.println("(3)B");
	}
	public B(String name) {
		super("(1)A");
		System.out.println(name);
	}
}

class C extends B {
	public C() {
		System.out.println("(4)C");
	}
	public static void main(String[] args) {
		new C();
	}
}

运行结果：
(1)A
(2)B
(3)B
(4)C

抽象类：
1、用abstract关键字来修饰一个类时，这个类叫抽象类，用abstract来修饰一个方法时，该方法叫抽象方法；
2、含有抽象方法的类必须被声明为抽象类；
3、抽象类不能被实例化；
4、抽象方法只需声明而不需实现。抽象方法没有内容，它只是为了标记出多态而存在。
   如：public abstract void enjoy();


final：
1、final的变量值不能够被改变(只可以在构造函数中被初始化时改变一次)；
2、final的方法不能被重写；
3、final的类不能被继承。


接口（interface）：
1、接口是抽象方法和常量值的定义的集合；
2、从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法
的实现；
 public interface Runner {
  public static final int id = 1；//等同于int id = 1；  public static final为声明的默认
  public void start();
 }
 3、接口可以多重实现；
 4、接口只能定义抽象方法，而这些方法默认为public，也只能是public；
 5、接口可以继承其他的接口，并添加新的属性和抽象方法，多个无关的类可以实现同一接口，一个
 类可以实现多个接口；
 6、与继承关系相似，接口与实现类之间存在多态性；用关键字implements


 多态实现的条件：
 1、要有继承；
 2、要有重写；
 3、父类引用指向子类对象。