>

JAVA基础体系,JAVA之面向对象贰

- 编辑:www.bifa688.com -

JAVA基础体系,JAVA之面向对象贰

接口定义:

1.继承    在Java中,类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类,子类会自动拥有父类所有可继承的属性和方法。

万事万物皆对象,对象是具有某些属性和功能的统一体。面向对象开发即不断地创建对象,使用对象,指挥对象,销毁对象。

  成员方法全是抽象的

继承的格式&使用: 在程序中,如果想声明一个类继承另一个类,需要使用extends关键字。

图片 1

  其接口内的抽象方法固定格式;public abstract 返回值类型 方法名(参数列表);

格式:    class 子类 extends 父类 {}

1. 类与对象

类:是一组相关的属性和行为的集合
对象:是该类事物的具体体现
举例:学生为一个类,某一具体的学生如班长就是一个对象

定义抽象方法:  

子类在继承父类的时候,会自动拥有父类的成员。

1.1 类的组成

**成员变量 构造函数 成员方法 **

class Person{
    public String name;
    public Integer age;
    public Person(String name,Integer age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

  接口内的方法都是公共方法的方法,public

继承的好处:

1.2 对象内存图

创建一个对象,要在栈区,堆区,方法区使用内存,具体见以下的Demo;

public class PersonDemo {
    public static void main(String[] args) {
        Person p1 = new Person("小红",11);
        Person p2 = new Person("小明",13);
    }
}

在内存分配中如下图:

图片 2

接口中成员变量的定义

1、继承的出现提高了代码的复用性,提高软件开发效率。

2. 几种变量

  • ### 2.1 局部变量与成员变量

图片 3

  • ### 2.2 成员变量与静态变量

图片 4

  接口中无法定义普通的成员变量

2、继承的出现让类与类之间产生了关系,提供了多态的前提。

3. 面向对象的特征

  格式:public static final 数据类型 数据名 = 值

在类的继承中,需要注意一些问题,具体如下:

3.1 封装

是指隐藏对象的属性和实现细节,仅对外提供公共访问方式.封装提高了代码的复用性和安全性。

 

1、在Java中,类只支持单继承,不允许多继承,也就是说一个类只能有一个直接父类2、多个类可以继承一个父类                      3、在Java中,多层继承是可以的,即一个类的父类可以再去继承另外的父类,例如C类继承自B类,而B类又可以去继承A类,这时,C类也可称作A类的子类                        ​ 4、在Java中,子类和父类是一种相对概念,也就是说一个类是某个类父类的同时,也可以是另一个类的子类。例如上面的这种情况中,B类是A类的子类,同时又是C类的父类。

3.2 继承

多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可

接口与接口之间可以实现多继承:

继承-子父类中成员变量的特点

3.2.1 格式

class 子类名 extends 父类名 {}

  实现类必须重写接口与接口的父类的所有方法

成员变量:如果子类父类中出现不同名的成员变量,这时的访问是没有任何问题。当子父类中出现了同名成员变量时,在子类中若要访问父类中的成员变量,必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。

3.2.2 特点

(1)Java只支持单继承,不支持多继承。

class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error

(2) Java支持多层继承(继承体系)

class A{}
class B extends A{}
class C extends B{}

好处:

在子类中,访问父类中的成员变量格式:

3.2.3 注意事项

(1) 子类只能继承父类所有非私有的成员(成员方法和成员变量)
(2) 子类不能继承父类的构造方法,但是可以通过super()关键字去访问父类构造方法。
Demo:

class Father {
    private int num = 10;
    public int num2 = 20;
    //私有方法,子类不能继承
    private void method() {
        System.out.println(num);
        System.out.println(num2);
    }
    public void show() {
        System.out.println(num);
        System.out.println(num2);
    }
}

class Son extends Father {
    public void function() {
        //num可以在Father中访问private
                //子类不能继承父类的私有成员变量
        //System.out.println(num); 
        System.out.println(num2);
    }
}

class ExtendsDemo {
    public static void main(String[] args) {
        // 创建对象
        Son s = new Son();
                //子类不能继承父类的私有成员方法
        //s.method();
        s.show();
        s.function();
    }
}

  接口的出现扩展了功能

        super.父类中的成员变量

3.3 多态

某一个事物,在不同时刻表现出来的不同状态.前提是要有继承关系,有方法重写
,有父类引用指向子类对象。

Demo:

public class PolymDemo {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        animal1.eat(); // 狗吃肉
        Animal animal2 = new Cat();
        animal2.eat(); // 猫吃鱼
    }
}

class Animal {
    public void eat() {
        System.out.println("eat");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

  接口其实就是暴露出来的功能

1.子父类中成员方法的特点

4. 类的初始化过程

图片 5

** Demo:**

public class ClassInitDemo {
    public static void main(String[] args) {
        Base tmp = new Derived();
        /** 初始化过程
         * Base:static init block invoked.. 1
         * Derived:static init block invoked... 2
         * Base:normal block invoked.. 3
         * Base:constructor invoked..  4
         * Derived:normal block invoked.. 5
         * Derived:constructor invoked.. 6
         */
    }
}

class Base {
    //1. 初始化父类中的静态成员变量和静态代码块
    static int b;
    static {
        System.out.println("Base:static init block invoked..");
    }

    //3. 初始化父类的普通成员变量和代码块
    int a;
    {
        System.out.println("Base:normal block invoked..");
    }

    //4. 执行父类的构造方法
    public Base() {
        System.out.println("Base:constructor invoked..");
    }

}

class Derived extends Base {
    //2. 初始化子类中的静态成员变量和静态代码块
    static int e = 4;
    static {
        System.out.println("Derived:static init block invoked...");
    }

    //5. 初始化子类的普通成员变量和代码块
    int d;
    {
        System.out.println("Derived:normal block invoked..");
    }

    //6. 执行子类的构造方法
    public Derived() {
        System.out.println("Derived:constructor invoked..");
    }
}

  接口降低的耦合性

当在程序中通过对象调用方法时,会先在子类中查找有没有对应的方法,若子类中存在就会执行子类中的方法,若子类中不存在就会执行父类中相应的方法。

5. 抽象类

在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。

  • ### 格式
abstract class 类名 {
     public abstract void 抽象方法名();
     public void 非抽象方法名();
}

** 注意: **
(a)抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
(b)抽象类有构造方法,但不能被初始化,构造方法用来给子类访问其成员变量
(c)abstract不能与private,final,static关键字共存

接口与抽象类的相同点:

成员方法特殊情况——覆盖

6. 接口

为了体现事物功能的扩展性,Java中就提供了接口来定义这些额外功能,并不给出具体实现

  都位于继承的顶端,用于被其他类实现或继承

子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为override重写、复写或者覆盖。

6.1 格式

//接口类
interface 接口名 {
    void 方法1();
    String 方法2();
}
//实现类
class 类名 implements 接口名 {
    void 方法1(){
        do something;
     }
    String 方法2(){
       do something;
    }
}

注意:
(a)接口不能实例化
(b)接口的子类要么是抽象类,要么重写接口中的所有抽象方法

  都不能直接实例化对象

2.方法重写(覆盖)的应用:

6.2 接口成员的特点

  • #### 成员变量

只能是常量
默认修饰符 public static final

  • #### 构造方法

没有,因为接口主要是扩展功能的,而没有具体存在成员方法

  • #### 只能是抽象方法

默认修饰符 public abstract

  都有抽象方法,子类都必须重写这些抽象方法

当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。

6.3 类与接口的关系

  • #### 类与类:

继承关系,只能单继承,但是可以多层继承

  • #### 类与接口:

实现关系,可以单实现,也可以多实现。还可以在继承一个类的同时实现多个接口

  • #### 接口与接口:

继承关系,可以单继承,也可以多继承

区别:

在子类中,访问父类中的成员方法格式:

6.4 接口与抽象类对比

图片 6

  抽象类是这个事物应该具有的内容

        super.父类中的成员方法();

7. 内部类

把类定义在其他类的内部,这个类就被称为内部类。

访问特点: 内部类可以直接访问外部类的成员,包括私有。外部类要访问内部类的成员,必须创建对象。
Demo:

class Outer {
    private int num = 10;
    class Inner {
        public void show() {
                        //可以直接访问外部类的私有成员变量
            System.out.println(num);
        }
    }
    public void method() {
        //找不到符号
        //show();
        Inner i = new Inner();
        i.show();
    }

}
  • ### 7.1 成员内部类
class Outer {
    public int num = 10;

    class Inner {
        public int num = 20;

        public void show() {
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
    }
}

class OuterDemo {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    } 
}
  • ### 7.2 局部内部类
class Outer {
    public void method() {
        final int n = 100;
        class Inner {
            public void show() {
                System.out.println(n);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    } 
}
  • ### 7.3 匿名内部类
abstract class Person {
    public abstract void show();
}

class PersonDemo {
    public void method(Person p) {
        p.show();
    }
}

class PersonTest {
    public static void main(String[] args) {
        //如何调用PersonDemo中的method方法呢?
        PersonDemo pd = new PersonDemo ();
        pd.method(new Person() {
            public void show() {
                System.out.println(“show”);
            }
        });
    }
}

  接口是这个事物中额外的内容

方法重写的注意事项

 

​ 子类方法覆盖父类方法,必须要保证权限大于等于父类权限。

优先使用接口

总结:当一个类是另一个类中的一种时,可以通过继承,来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时,进行方法重写。

 

二.抽象类    分析事物时,发现了共性内容,就出现向上抽取。会有这样一种特殊情况,就是方法功能声明相同,但方法功能主体不同。那么这时也可以抽取,但只抽取方法声明,不抽取方法主体。那么此方法就是一个抽象方法。

抽象方法定义的格式:                                public abstract 返回值类型 方法名(参数);

抽象类定义的格式: abstract class 类名 {  }

抽象类的特点:

1、抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。    2、抽象类不可以直接创建对象,原因:调用抽象方法没有意义。                                3、只有覆盖了抽象类中所有的抽象方法后,其子类才可以创建对象。否则该子类还是一个抽象类。

之所以继承抽象类,更多的是在思想,是面对共性类型操作会更简单。

3.接口:理解为是一个特殊的抽象类,但它不是类,是一个接口

接口的特点:

1,定义一个接口用interface关键字 interface Inter{}

2,一个类实现一个接口,实现implements关键字    class Demo implements Inter{}

3, 接口不能直接创建对象

通过多态的方式,由子类来创建对象,接口多态

接口中的成员特点:

成员变量:只能是final 修饰的常量

默认修饰符: public static final

成员方法:只能是抽象方法

默认修饰符: public abstract

类与类,类与接口,接口与接口之间的关系

类与类之间:继承关系,单继承,可以是多层继承

类与接口之间: 实现关系,单实现,也可以多实现

接口与接口之间:继承关系,单继承,也可以是多继承

Java中的类可以继承一个父类的同时,实现多个接口

4.多态:理解为同一种物质的多种形态

多态使用的前提:

1,有继承或者实现关系

2,要方法重写

3,父类引用指向子类对象

多态的成员访问特点:方法的运行看右边,其他都看左边

多态的好处:提高了程序的扩展性

多态的弊端:不能访问子类的特有功能

多态的分类

  类的多态

abstract class Fu { 

public abstract void method();

}

class Zi extends Fu {

public void method(){

System.out.println(“

}

}

//类的多态使用

Fu fu= new Zi();

接口的多态

interface Fu {

public abstract void method();

}

class Zi implements Fu {

public void method(){

System.out.println(“重写接口抽象方法”

}

}

//接口的多态使用

Fu fu = new Zi();

instanceof 关键字

格式: 对象名 instanceof 类名                    返回值: true, false                                        作用: 判断指定的对象 是否为 给定类创建的对象

本文由必发88官网发布,转载请注明来源:JAVA基础体系,JAVA之面向对象贰