RT，我们平时在用继承类时，常常想为什么父类里的成员变量，为什么我非要覆盖。我专心扩展我的东西不是更简约吗？



class A{
    int a=0;
    int b=0;
    String str="0";
    String str2="0";
}
class B extends A{
    int b=0;
    String str="0";
    {
        a=114;
        b=114;
        str="213";
        str2="213";
        System.out.println("super.a="+super.a);
        System.out.println("super.b="+super.b);
        System.out.println("super.str="+super.str);
        System.out.println("super.str2="+super.str2);
    }

    void f(A ad){
        a=11;
        b=11;
        str="21";
        str2="21";
        System.out.println("super.a="+super.a);
        System.out.println("super.b="+super.b);
        System.out.println("super.str="+ad.str);
        System.out.println("super.str2="+ad.str2);
    }


}
public class Main {
    public static void main(String[] args) {
        B b=new B();
        b.f(b);
    }

}

在A中       在B中  

  int n        /            b.n实际使用的是super.n 

  int n       int n        b.n就是b.n 

  现在你要修改B.n，第一种情况实际更改的是super.n 

  第二种情况才是修改真正的B对象中的n

现在我用抽象类试一下，为了保证abastract里数据能调用，为它们加上static(但是注意抽象方法是用不了static，static声明的方法必须有方法体)

abstract class Fu{
    static int a1=1;
    static int a2=1;
    static String b1="123";
    static String b2="123";

}
class Zi extends Fu{
    int a2=1;
    String b2="123";



}
public class Test1 {
 public static void main(String[] args) {
    Zi z=new Zi();
    z.a1=299;
    z.a2=299;
    z.b1="12345";
    z.b2="12345";
    System.out.println(Fu.a1);
    System.out.println(z.a1);
    System.out.println(Fu.b1);
    System.out.println(z.b2);
}
}

输出结果为 

299 

299 

12345 

12345

可见也是成立的  

—————————–一句话总结——————————- 

对象的数据属性  直接使用的是  最近一次覆盖的地方和值！

Java面向对象
作者q：2835916127
一、继承篇
1. 继承的实现


继承的概念：

继承是面向对象三大特性之一，继承可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加子类新的方法



实现继承的格式


格式 ： class 子类 extends 父类{ }


举例：

class Dog extends Animal { }

这里不详细举例了


继承带来的好处：

提高了代码的复用性（多个类的属性只需要在基类中声明）
提高了代码的维护性（需要修改时，只需要修改一处即可）



继承带来的弊端

继承使得子类与父类产生了关系，类的耦合性增强了，当父类需要更改时，子类不得不做出改变，削弱了子类的独立性



继承的使用

使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用继承

is…a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类





2.继承的访问特点
变量的访问特点

在子类中访问一个变量，采用的是就近原则


在子类的局部范围内查找
在子类的成员范围内查找
在父类的成员方法中查找
如果三种都没查找到就报错（不考虑父亲的父亲）

对象的访问特点

创建

this和super


this：当前类对象的引用


super：父类对象的引用


构造函数：

this(参数1,参数2…)
super(参数1,参数2…)



注意：子类创建时都默认调用父类super()构造函数

创建子类对象时，如果不显式调用父类的构造方法，那么默认会调用父类的super()方法
如果需要调用父类的构造函数，必须把super(参数1,参数2…) 放在子类构造函数第一句
不能一个子类调用多次父类构造

推荐写法： 创建类时把默认构造带上

方法重写：

重写概念：子类中写有与父类一样的方法声明，即方法名、参数类型相同
应用场景：当子类需要父类的功能，并且子类某个方法具有其特有的方法，此时就可以重写父类方法
可以使用注解 @Override 来验证子类中声明的方法是否来自父类，起到【校验】功能

注意事项：

父类私有方法不能被重写（父类的私有成员及方法不能被子类继承）
子类的访问权限不能比父类低（public > protected > 默认（不写权限） > private）




public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {

    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

注意事项：


java只支持单继承（一个爸爸多个儿子）


java中类支持多层继承


注意重写和重载的区别

重写：子类覆盖父类的方法
重载：同一个类中，方法名相同，参数个数或类型不同



final


final代表最终的意思，可以成员方法、成员变量、类

final修饰类
final修饰类：该类不能被继承（不能有子类，但是可以有父类）
final修饰成员方法：该方法不能被重写
final修饰成员变量：表示该变量是一个常量，不能被重新赋值



final修饰基本数据类型

final修饰的基本数据类型，其值不能改变
final修饰引用类型：其引用类型的地址值不能改变，但是地址里边的内容是可以改变的



举例


public static void main(String[] args){
    final Student s = new Student(23);
  	s = new Student(24);  // 错误
 	s.setAge(24);  // 正确
}

static


概念：static是静态的意思，可以修饰成员方法 和 成员变量


特点：

被类的所有对象共享，这也是判断使用静态的条件
可以通过类名调用（推荐使用）

static的访问特点




非静态的成员方法

能访问静态的成员变量
能访问非静态的成员变量
能访问静态的成员方法
能访问非静态的成员方法


静态的成员方法

能访问静态的成员变量
能访问静态的成员方法


总结成一句话就是：

静态成员方法只能访问静态成员

对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。私有成员能继承，但是由于访问权限的控制，在子类中不能直接使用父类的私有成员。
当两个类存在逻辑上的"is-a"关系时，可以采用继承进行代码的复用。
继承是软件复用的一种形式，但不是所有的软件复用都用继承。
继承是多态的前提，没有继承就没有多态。
java中是单继承，一个子类只能有一个父类
继承中的构造方法
当生成子类对象时，Java默认首先调用父类的不带参数的构造方法，然后执行该构造方法，生成父类的对象。接下来，再去调用子类的构造方法，生成子类的对象。【要想生成子类的对象，首先需要生成父类的对象，没有父类对象就没有子类对象。比如说：没有父亲，就没有孩子】。
如果子类使用super()显式调用父类的某个构造方法，那么在执行的时候就会寻找与super()所对应的构造方法而不会再去寻找父类的不带参数的构造方法。与this一样，super也必须要作为构造方法的第一条执行语句，前面不能有其他可执行语句。
当两个方法形成重写关系时，可以在子类方法中通过super.run()形式调用父类的run()方法，其中
继承的要点
(1)继承使用 extends 关键字
class Super{    //父类  super class  超类
}
//Sub "is-a" Super
class Sub extends Super{  //子类 sub class 继承自父类
}
(2)java 只允许单继承
(3)Object 类是所有类的共同父类(最顶层)，任何一个类直接或间接的继承自Object类
(4)创建子类对象会先创建父类对象
调用子类构造方法会先递归地调用其父类构造方法
this关键字    表示本类对象
this.成员    常用于 this.成员变量    用于区分同名的局部变量
this.name = name;
this()  表示调用本类的构造方法   可以传参数
super关键字  表示父类对象
super.成员   常用于 super.成员方法  用于区分父子类同名的方法
super()      表示调用父类的构造方法  可以传参数
Java规定：任何构造方法的第一行，默认都是：super();
(5) 子类能够从父类继承到能继承到的资源
前提：使用public或protecetd修饰的
方法的覆盖(Override 重写)
一定存在于子类和父类之间。如果子类对父类的方法不满意，可以覆盖父类中的方法，覆盖也称为重写。
规定：
1)子类覆盖方法和父类被覆盖方法的方法的三要素：返回类型，方法名称，参数列表必须相同
2)子类覆盖方法的访问权限必须大于等于父类的方法的访问权限
3)子类覆盖方法不能比父类被覆盖方法抛出更多异常
方法的重载(Overload)
一般在一个类中，使用相同的方法名、不同的参数表
何为不同：(类型、数量、顺序)
好处：便于开发者的使用，记忆少量的方法名
方法重写与方法重载之间的关系：重载发生在同一个类内部的两个或多个方法。重写发生在父类与子类之间。
final关键字在继承中的使用
final可以用于以下四个地方：
定义变量，包括静态的和非静态的。
如果final修饰的是一个基本类型，就表示这个变量被赋予的值是不可变的，即它是个常量；
如果final修饰的是一个对象，就表示这个变量被赋予的引用是不可变的，不可改变的只是这个变量所保存的引用，并不是这个引用所指向的对象，其实更贴切的表述final的含义的描述，那就是，如果一个变量或方法参数被final修饰，就表示它只能被赋值一次，但是JAVA虚拟机为变量设定的默认值不记作一次赋值。
被final修饰的变量必须被初始化。初始化的方式有以下几种：
1. 在定义的时候初始化。
2. 在初始化块中初始化。
3. 在类的构造器中初始化。
4. 静态变量也可以在静态初始化块中初始化。
1) 定义方法。
当final用来定义一个方法时，它表示这个方法不可以被子类重写，但是它这不影响它被子类继承。
说明：
具有private访问权限的方法也可以增加final修饰，但是由于子类无法继承private方法，因此也无法重写它。编译器在处理private方法时，是按照final方法来对待的，这样可以提高该方法被调用时的效率。不过子类仍然可以定义同父类中的private方法具有同样结构的方法，但是这并不会产生重写的效果，而且它们之间也不存在必然联系。
3)定义类。
由于final类不允许被继承，编译器在处理时把它的所有方法都当作final的，因此final类比普通类拥有更高的效率。final的类的所有方法都不能被重写，但这并不表示final的类的属性(变量)值也是不可改变的，要想做到final类的属性值不可改变，必须给它增加final修饰。
super.run()不必放在第一行语句，因此此时父类对象已经构造完毕，先调用父类的run()方法还是先调用子类的run()方法是根据程序的逻辑决定的。
关于继承的几点注意：
a) 父类有的，子类也有
b) 父类没有的，子类可以增加
c) 父类有的，子类可以改变
d) 构造方法不能被继承
e) 方法和属性可以被继承
f) 子类的构造方法隐式地调用父类的不带参数的构造方法
g) 当父类没有不带参数的构造方法时，子类需要使用super来显式地调用父类的构造方法，super指的是对父类的引用
h) super关键字必须是构造方法中的第一行语句。

1.封装
封装的定义：
首先是抽象，把事物抽象成一个类，其次才是封装，将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系
为什么需要封装：
封装符合面向对象设计原则的第一条：单一性原则，一个类把自己该做的事情封装起来，而不是暴露给其他类去处理，当内部的逻辑发生变化时，外部调用不用因此而修改，他们只调用开放的接口，而不用去关心内部的实现
举例：
public classHuman
{
private intage;
privateString name;
public intgetAge()
{
returnage;
}
public void setAge( int age ) throwsException
{
//封装age的检验逻辑，而不是暴露给每个调用者去处理
if( age > 120)
{
throw new Exception( "Invalid value of age");
}
this.age =age;
}
publicString getName()
{
returnname;
}
public voidsetName( String name )
{
this.name =name;
}
}
2. 继承
Java的类可以分为三类：
类：使用class定义，没有抽象方法
抽象类：使用abstract class定义，可以有也可以没有抽象方法
接口：使用inerface定义，只能有抽象方法
在这三个类型之间存在如下关系：
类可以extends：类、抽象类(必须实现所有抽象方法)，但只能extends一个，可以implements多个接口(必须实现所有接口方法)
抽象类可以extends：类，抽象类(可全部、部分、或者完全不实现父类抽象方法)，可以implements多个接口(可全部、部分、或者完全不实现接口方法)
接口只能extends一个接口
继承以后子类可以得到什么：
子类拥有父类非private的属性和方法
子类可以添加自己的方法和属性，即对父类进行扩展
子类可以重新定义父类的方法，即多态里面的覆盖，后面会详述
关于构造函数：
构造函数不能被继承，子类可以通过super()显示调用父类的构造函数
创建子类时，编译器会自动调用父类的 无参构造函数
如果父类没有定义无参构造函数，子类必须在构造函数的第一行代码使用super()显示调用
类默认拥有无参构造函数，如果定义了其他有参构造函数，则无参函数失效，所以父类没有定义无参构造函数，不是指父类没有写无参构造函数。看下面的例子，父类为Human，子类为Programmer。
public classHuman
{
//定义了有参构造函数，默认无参构造函数失效
publicHuman(String name)
{
}
}
public classProgrammer
extendsHuman
{
publicProgrammer()
{
//如不显示调用，编译器会出现如下错误
//Implicit super constructor Human() is undefined. Must explicitly invoke another constructor
super( "x");
}
}
为什么需要继承：
代码重用是一点，最重要的还是所谓想上转型，即父类的引用变量可以指向子类对象，这是Java面向对象最重要特性多态的基础
3. 多态
在了解多态之前，首先需要知道方法的唯一性标识即什么是相同/不同的方法：
一个方法可以由：修饰符如public、static+返回值+方法名+参数+throw的异常 5部分构成
其中只有方法名和参数是唯一性标识，意即只要方法名和参数相同那他们就是相同的方法
所谓参数相同，是指参数的个数，类型，顺序一致，其中任何一项不同都是不同的方法
何谓重载：
重载是指一个类里面(包括父类的方法)存在方法名相同，但是参数不一样的方法，参数不一样可以是不同的参数个数、类型或顺序
如果仅仅是修饰符、返回值、throw的异常 不同，那这是2个相同的方法，编译都通不过，更不要说重载了
//重载的例子
public classProgrammer
extendsHuman
{
public void coding() throwsException
{
}
public voidcoding( String langType )
{
}
publicString coding( String langType, String project )
{
return "";
}
}
//这不是重载，而是三个相同的方法，编译报错
public classProgrammer
extendsHuman
{
public void coding() throwsException
{
}
public voidcoding()
{
}
publicString coding()
{
return "";
}
}
何谓覆盖/重写：
覆盖描述存在继承关系时子类的一种行为
子类中存在和父类相同的方法即为覆盖，何谓相同方法请牢记前面的描述，方法名和参数相同，包括参数个数、类型、顺序
public classHuman
{
public voidcoding( String langType )
{
}
}
public classProgrammer
extendsHuman
{
//此方法为覆盖/重写
public voidcoding( String langType )
{
}
//此方法为上面方法的重载
public voidcoding( String langType, String project )
{
}
}
覆盖/重写的规则：
子类不能覆盖父类private的方法，private对子类不可见，如果子类定义了一个和父类private方法相同的方法，实为新增方法
重写方法的修饰符一定要大于被重写方法的修饰符(public > protected > default > private)
重写抛出的异常需与父类相同或是父类异常的子类，或者重写方法干脆不写throws
重写方法的返回值必须与被重写方法一致，否则编译报错
静态方法不能被重写为非静态方法，否则编译出错
理解了上述知识点，是时候定义多态了：
多态可以说是“一个接口，多种实现”或者说是父类的引用变量可以指向子类的实例，被引用对象的类型决定调用谁的方法，但这个方法必须在父类中定义
多态可以分为两种类型：编译时多态(方法的重载)和运行时多态(继承时方法的重写)，编译时多态很好理解，后述内容针对运行时多态
运行时多态依赖于继承、重写和向上转型
上例子：
classHuman
{
public voidshowName()
{
System.out.println( "I am Human");
}
}
//继承关系
classDoctor
extendsHuman
{
//方法重写
public voidshowName()
{
System.out.println( "I am Doctor");
}
}
classProgrammer
extendsHuman
{
public voidshowName()
{
System.out.println( "I am Programmer");
}
}
public classTest
{
//向上转型
publicHuman humanFactory( String humanType )
{
if( "doctor".equals( humanType ) )
{
return newDoctor();
}
if( "programmer".equals( humanType ) )
{
return newProgrammer();
}
return newHuman();
}
public static voidmain( String args[] )
{
Test test = newTest();
Human human = test.humanFactory( "doctor");
human.showName();//Output:I am Doctor
human = test.humanFactory( "programmer");
human.showName();//Output:I am Programmer
//一个接口的方法，表现出不同的形态，意即为多态也
}
}
向上转型的缺憾：
只能调用父类中定义的属性和方法，对于子类中的方法和属性它就望尘莫及了，必须强转成子类类型
总结概括：
当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)
稍微复杂的例子：
classHuman {
public voidfun1() {
System.out.println("Human fun1");
fun2();
}
public voidfun2() {
System.out.println("Human fun2");
}
}
class Programmer extendsHuman {
public voidfun1(String name) {
System.out.println("Programmer's fun1");
}
public voidfun2() {
System.out.println("Programmer's fun2");
}
}
public classTest {
public static voidmain(String[] args) {
Human human = newProgrammer();
human.fun1();
}
/** Output:
*  Human fun1
*  Programmer's fun2
*/}
Programmer中的fun1(String name) 和Human中的fun1()，只是方法名相同但参数不一样，所以是重载关系
Programmer中的fun2()和Human中的fun2()是相同的方法，即Programmer重写了Human的fun2()方法
把Programmer的对象向上转型赋值个Human后，human.fun1()会调用父类中的fun1()方法，子类的fun1(String name)是不同的方法
在human的fun1()中又调用了fun2()方法，该方法在Programmer中被重写，实际调用的是被引用变量Programmer中的fun2()方法
packagetest;
classA {
public voidfunc() {
System.out.println("func in A");
}
}
class B extendsA {
public voidfunc() {
System.out.println("func in B");
}
}
class C extendsB {
public voidfunc() {
System.out.println("func in B");
}
}
public classBar {
public voidtest(A a) {
a.func();
System.out.println("test A in Bar");
}
public voidtest(C c) {
c.func();
System.out.println("test C in Bar");
}
public static voidmain(String[] args) {
Bar bar = newBar();
A a = newA();
B b = newB();
C c = newC();
bar.test(a);
bar.test(b);
bar.test(c);
/*func in A
test A in Bar
func in B
test A in Bar
func in B
test C in Bar
*/}
}