Java继承（面向对象编程）

Java面向对象包含的内容很多（面向对象的基本概念，类和对象，继承，接口，嵌套类和匿名类，反射，注解等等）。
所谓面向对象，就是其程序设计是以对象（Object)类为核心，以对象所拥有的数据状态和功能行为为工具解决特定问题。
每个对象都拥有两个属性：状态（state）和行为（Behavior）。

继承

Java语法中通过extends关键字实现类的继承机制。
通过继承，子类自动拥有了基类的所有成员（成员变量和成员方法）。
Java只支持单继承，不允许多继承。即一个子类只能有一个基类，一个基类可以派生出多个子类。

对象成员的访问权限

修饰符	类内部	同一个包	子类	任何地方
private	Yes	Yes	部分Yes
default	Yes	Yes	部分Yes
protected	Yes
public	Yes	Yes	Yes	Yes

子类重写父类的方法

1.在子类的基类中可以根据需要对从基类中继承的方法进行重写
2.重写方法必须和被继承方法具有相同的名称
3.重写方法不能使用比被重写方法更严格的访问权限

public class T_OverWrite {     //父类
int age;     
String name;     
void setAge(int age) {  this.age = age;  }     
void setName(String name)  { this.name = name;   }    
int getAge() {      return age;     }     
String getName() {      return name;     } 
public String getInfo() {      return ("我的名字是"+name+"我的年龄："+age);     } }  


public class Student extends T_OverWrite {
String school; 
 void setSchool(String school) {
  this.school = school;
 }
 String getSchool() {
   return school;
 }
 public String getInfo() { //这里就是重写了父类的方法
     return ("我的名字是"+name+"我的年龄："+age+"我的学校是"+school);
  }
  public static void main(String[] args) {
  T_OverWrite person = new T_OverWrite();
  Student student = new Student();
   person.setAge(20);
   person.setName("rong");
   student.setAge(21);
   student.setName("1ing");
   student.setSchool("哈哈");    
   System.out.println(person.getInfo());
   System.out.println(student.getInfo());
   }
   }

Static

1.在类中声明的static变量是静态成员变量，
2.它是该类的共有变量，在第一次使用时被初始化。
3.对于该类的所有成员变量来说，static成员变量只有一份 。
4.可以通过对象的引用和类名访问该变量

public class T_Static {
 private static int sid=0;
 private String name;
 int id;
 T_Static(String name) {
  this.name = name;
  id = sid++;  
 }
 void print() {
  System.out.println("My name is "+name+"NO."+id);
 }
 public static void main(String[] args) {
    T_Static.sid = 100;//通过类名的调用改变static变量
    T_Static one = new T_Static("小明");
    one.sid = 1000;//通过对象的引用改变static变量
    T_Static two = new T_Static("小华");
    one.print();
    two.print();
 }
}

this

1.this可以看成一个对象，它的值是对当前对象的引用
2.当必须要指出使用方法的对象是要使用this

public class This {
    int i;
    This(int i) {
     this.i = i;
    }
    This add() {
     i++;
     return this;//将i的值返回给当前这个对象
    }
    void print() {
     System.out.println(i);
    }
 public static void main(String[] args) {  
    This rr = new This(100);
    rr.add().add().print();
 }
}

super

1. super关键字的作用其中之一是子类重写父类的方法时，需要保留父类方法的语句时，可以用super语句调用。

public class T_Super {
 public int value;
 public void way() {
  value = 100;
  System.out.println("父类的value："+value);
 }
}

class _Super extends T_Super {
 public int value;
 public void way() {
  super.way();//调用父类的way
  value = 200;
  System.out.println("子类的value："+value);
  System.out.println("父类的value："+super.value);
 }
 public static void main(String[] args) {
  _Super rr = new _Super();
  rr.way();
 }
}

2. 子类构造的过程中必须要调用父类的构造方法。
3. 子类可以用super关键字调用父类的构造方法，且super语句必须写在子类构4造方法的第一行。
4. 如果子类中没有显示调用父类的构造方法，则默认调用父类无参数的构造方法
5. 如果子类中没有显示调用父类的构造方法，而且父类中没有无参的构造方法，则编译出错。

public class Superclass {
    private int n;
    Superclass() {
     System.out.println("Superclass()");
    }
    Superclass(int n) {
     System.out.println("Superclass("+n+")");
     this.n= n;
     
    }
}

public class Subclass extends Superclass {
 private int n;
    Subclass() {
     //super(300);
     System.out.println(" Subclass");
    }
    Subclass(int n) {
     super(300);
     System.out.println("Subclass("+n+")");
    }
 public static void main(String[] args) {
  Subclass su1 = new Subclass();
  Subclass su2 = new Subclass(300); 
 }
}

对象的引用转型

1 一个基类的引用变量可以”指向“其子类的对象
2 一个基类的引用变量不能访问子类新增加的成员（属性和方法)
3 可以使用 引用变量+instanceof+类名 判断该引用型变量所指的对象是否属于该类或该类的子类
4 子类的对象可以当作基类对象来使用称为上转型，反之则称之为下转型
以下面小程序为例：

public class Animal {
public String name;
Animal(String name) {
 this.name = name;
}
}

public class Cat extends Animal {
public String eyecolor;
 Cat(String name, String c) {
   super(name);
  this.eyecolor = c;  
 }
}

public class Dog extends Animal {
public String furcolor;
 Dog(String name, String f) {
   super(name);
  this.furcolor = f;
 }
  public void f(Animal obj) {
  System.out.println("动物的名字:"+obj.name);
  if(obj instanceof Cat) {
     Cat ca = (Cat)obj;
   System.out.println("猫眼的颜色::"+ca.eyecolor);
  }
  }
   public static void main(String[] args) {
    Animal a = new Animal("a");
    Cat c = new Cat("c","blue");
    Dog d = new Dog("d","yellow");
    d.f(c);
    System.out.println(a instanceof Animal);//true
    System.out.println(c instanceof Animal);//true
    System.out.println(d instanceof Animal);//true
    System.out.println(a instanceof Dog); //false  
    Animal animal = new Dog("g","pink");//这里a虽然成了一条狗，但它只看到作为Animal的部分(向上转型）
    System.out.println(animal.name);//只能看到名字
    //System.out.println(a.furcolor);//编译错误
    Dog d1 = (Dog)animal;//要加强制转换符
    System.out.println(d1.furcolor); 
    Cat cat =(Cat)a;//向下转型，编译无错误，运行时出错
    System.out.println(cat.name);
  }