目标
今天学习了定义在类里面的内部类，代码块，Java里面的继承和多态的特性。
学习
内部类
在Java里面我们在定义一个类的时候，我们可以单独创建一个类，也可以将一个类创建在另外一个类或者一个方法里面里面，我们将这个类称作内部类。
我们在代码中使用内部类的好处：内部类可以进行更好的封装。
我们在一个类A里面创建另一个类B，例如：
class Person{
private String name;
int age;
class heightWeight{
int height;
int weight;
}
}
能够看到类heightWeight就像是类Person的成员一样，像这种内部类，称作成员内部类，其可以无条件的访问外部类的所有成员属性和成员方法。
在成员内部类中要注意两点
第一：成员内部类中不能存在任何static的变量和方法；
第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。
静态内部类
是由static所修饰的内部类
静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
public class Test {
public static void main(String[] args) {
Outter.Inner inner = new Outter.Inner();
}
}
class Outter {
public Outter() {
}
static class Inner {
public Inner() {
}
}
}
一般来说内部类访问外部类的成员很方便，但是外部类访问内部类的成员却很麻烦。需要进行下面的操作。
创建成员内部类对象：外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
创建静态内部类对象：外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()
在创建了内部类对象之后我们就可以访问内部类的成员属性
代码块
静态代码块
在java类中的格式如下
class Person3{
static {
System.out.println("静态代码块");
}
}
静态代码块由static修饰，因此静态代码块在类被加载的时候就运行了，而且只运行一次，并且优先于各种代码块以及构造函数。如果一个类中有多个静态代码块，会按照书写顺序依次执行。
例如：
public class text3 {
public static void main(String[] args){
Person3 person=new Person3();
}
}
class Person3{
static {
System.out.println("静态代码块1");
}
static {
System.out.println("静态代码块2");
}
static {
System.out.println("静态代码块3");
}
}
值得注意的是：静态代码块里面不能调用实例方法和成员变量
执行结果如下：
还有没有被static所修饰的代码块
public class CodeBlock {
{
System.out.println("构造代码块");
}
}
构造代码块在创建对象时被调用，每次创建对象都会调用一次，构造代码块不是优先于构造函数执行，而是依托于构造函数，也就是说，如果你不实例化对象，构造代码块是不会执行的。
一个类里面可以有多个代码块，执行顺序按照先后顺序实行。静态代码块的执行要有限于普通代码块
继承
类的继承提高了程序代码的重用性和可扩充性，缩短了软件开发的周期。
实现继承的类成为子类，被继承的类叫做父类；子类和父类的关系，是一般和特殊的关系；
class Person{
public double weight;
public void eat(){
System.out.println("吃东西");
}
}
class Studebt extends Person{
public void say(){
System.out.pringln(“你好”);
}
public static void main(String[] args) {
Studebt d= new Student();
d.weight = 150;
d.eat();
d.say();
}
}
子类扩展父类--总是以父类为基础，额外增加新的属性和方法。但有一种情况例外：子类需要重写父类的方法。
子类覆盖父类的方法遵循的是“两同两小一大”原则。两同指的是方法名和形参列表相同。两小指的是子类方法的返回值类型要小于或等于父类被覆盖方法的返回值，子类方法声明抛出的异常应比父类方法抛出的异常要小或相等。一大指的是子类方法的访问权限应该比父类方法要大或相等。
子类重写父类的方法
class Person1{
String name;
int age;
public Person1(String name,int age){
}
public void walk(){
System.out.println("走路");
}
public void eat(){
System.out.println("吃饭");
}
}
class Student extends Person1{
int id;
String school;
public Student(String name,int age,int id,String school){
super(name,age);
this.id=id;;
this.school=school;
}
@Override
public void walk(){
System.out.println("走寻常路");
}
@Override
public void eat(){
System.out.println("大口吃饭");
}
}
}
super的使用
super代表父类对象
什么情况下需要早一个方法里面调用super的对应方法
如果一个人方法需要完成一个功能 又不能独立完成 必须要父类做相应的工作
1.父类做完之后 子类在进行操作
2.子类做对岸事情之后再用父类去调用
如果子类里面需要重新实现父类的方法就需要重写
如果父类自定义了构造方法
子类应该调用父类的构造方法
写在后面
认真学习，认真学习，认真学习。
