03Java面向对象

本文主要是介绍03Java面向对象，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

面向过程和面向对象的设计思想

面向过程：是一种程序设计思想。C语言

解决问题时，是按具体的实现步骤一步一步实现。

面向过程直接关注流程。

eg. 首先开门（）

其次装大象（）

最后关门（）

面向对象：是一种程序设计思想。Java、Python，C++，C#

以分类的方式进行思考和解决问题。

先对整体关系进行分类，根据不同的类深入细节的处理。

符合人类认知习惯。

面向对象 —> 使用对象对象是什么对象从何而来
面向对象实现：对客观事物进行分类（设计类/发现类类是抽象的），实际使用时，需要以类为模板创建出一个个具体的对象。

人类 —> 张三（对象）

设计一个冰箱类（抽象的）

public class 冰箱{

名字

型号

价格

开门（）；

装大象；

关门（）；

}

冰箱 bx = new 冰箱（）； //bx表示这个对象，在运行时在内存中会划出一块空间，用来存储具体的对象。

bx.开门（）； //具体的对象

冰箱.开门（）； //错误冰箱是一个概念

面向对象是在宏观整体上对事物之间的关系进行设计，具体实现又回归到面向过程的具体实现，两者是相辅相成的。

什么是类

类是一个模板，是对同一类事物属性（名词）和行为（动词）的抽象。

类是有地址的，包就是其地址。

类是一个模板，它是

类的结构：

成员变量：事物属性的描述。名词属性

成员变量在定义是，可以对其初始化，也可以不进行初始化，java会在构造方法中对其进行默认赋值。引用类型值为：null int：0 float：0.0 char：‘ ’ boolean：false

局部变量需要自己对其初始化。

创建对象时，会从类中向对象中复制一份成员变量到对象中

成员变量可以被方法，构造方法，代码块所访问
成员方法：事物的行为。（可以做的事情）动词行为
构造方法：初始化对象。有专职作用初始化对象
内部类：即在类体中声明的类。
代码块：一段没有名称的代码。

类的定义：

发现类
发现类的共有属性（成员变量）
发现类的方法

以类为模板创建对象使用对象。

万事万物（实际存在的事物具体）皆为对象

//Car.java

/*发现类  汽车类
* public（访问权限修饰符）  class（关键字修饰类）  Car（类名）
* {
*      类体
*      成员变量
*      成员方法
*      构造方法
* }*/
public class Car {
    /*
        定义类的成员变量   名词  属性
        直接定义在类中，所以成为类的成员
        可以使用java所支持的任意的数据类型   基本类型、引用类型
    */
    String name;  //引用类型
    String color;
    float price;  //基本类型

    /*
        定义类的成员方法   动词  行为
    */
    public void run(){
        System.out.println(this.name+"汽车行驶");
    }

    public void stop(){
        System.out.println(name+"汽车停止");
    }

}

什么是对象

对象是类的一个实例，是以类为模板在内存中创建的实际存在的实例。

//TestCar.java

public class TestCar {
    public static void main(String[] args) {
        /*
            类是模板，是抽象概念  就是一个定义
            对象是具体，可以直接被使用的，是以类为模板，在内存中创建出来的实际存在的实例
        */
        Car bm = new Car();
        bm.name = "宝马";
        bm.color = "黑色";
        bm.price = 200000;
        System.out.println(bm.name);
        bm.run();
        bm.stop();

        Car bc = new Car();
        bc.name = "奔驰";
        bc.color = "黑色";
        bc.price = 2043000;
        System.out.println(bc.name);
        bc.run();
        bc.stop();
    }
}

对象的创建和使用：

Car bm = new Car();
Car() 构造方法构造方法的名字与类名相同new Car() new 关键字，创建对象。

以Car类为模板，在内存中创建一个具体实例将类这个模板中的成员向具体对象中复制一份，每个对象中都是独一无二的。
Car bm/bc 声明了一个类型为Car的变量。
= 将右边的对象地址赋值给左边的变量，左边的变量就在程序中表示内存中的对象。
同一类的每个对象有不同的成员变量存储空间。
同一类的每个对象共享该类的方法。

类和对象

类是一类事物的抽象概念，是一个模型。

对象是由这个模型所创造的一个个具体存在的,实实在在存在的实例。所以创建对象的过程也叫实例化对象。

现实生活中先有对象后有类，而编程时先设计类后创建对象。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T07lZ2qF-1642687013926)(E:\Java学习\2022-1-16java第三章面向对象1\课件\创建对象简图.png)]

构造方法

特点：构造方法名与类名相同，且没有返回值，且不需要void修饰。

作用：在构造方法中为创建的对象初始化赋值。

每次创建对象时，至少要调用一个构造方法，一个类中可以有多个构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方法后，默认的无参构造方法即失效。

一个类可以有多个构造方法。

//Car.java

public class Car {

    String name;
    String color;
    float price;

    /*
       类中默认的无参构造方法，默认是有的，
       如果没有显示的写出来，如果定义了有参的构造方法，那么无参的就会被覆盖
       以后一般情况下，定义了有参的构造方法，最好把无参显示定义出来
    */
    public Car(){
        //在无参构造方法中，可以使用默认值为对象中的属性赋值
        //引用类型：null  整数：0   浮点：0.0  char：‘ ’  boolean:false
    }

    public void run(){
        System.out.println(this.name+"汽车行驶");
    }

    public void stop(){
        System.out.println(name+"汽车停止");
    }

}

//TestCar.java
public class TestCar {
    public static void main(String[] args) {
        /*
            new Car()  ---> 构造方法
            特点：构造方法名与类名相同，且没有返回值，且不需要void修饰
            作用:在构造方法中为创建的对象初始化赋值
            每次创建对象时，至少要调用一个构造方法，一个类中可以有多个构造方法
        */
        Car bm = new Car();
        bm.name = "宝马";
        bm.color = "黑色";
        bm.price = 200000;
        bm.run();
    }
}

方法的重载

在一个类中有多个方法名称相同的现象。

构造方法，成员方法都可以重载。

如何区分方法：

通过方法参数个数区分
通过类型区分
通过顺序区分

调用时，会根据不同的参数表选择对应的方法。

注意：方法重载跟方法的返回值类型没有任何关系。

重载的作用：扩展方法功能。

//构造方法
public Car(){
    //在无参构造方法中，可以使用默认值为对象中的属性赋值
    //引用类型：null  整数：0   浮点：0.0  char：‘ ’  boolean:false
}

public Car(String name,String color,float price){
    //this表示当前正在被使用的对象
    this.name = name;  //此name是成员变量中的name
    this.color = color;
    this.price = price;
}
//构造方法
public Car(String name,String color){
    this.name = name;  //此name是成员变量中的name
    this.color = color;
}

public Car(float price,String name,String color){
    //this表示当前正在被使用的对象
    this.name = name;  //此name是成员变量中的name
    this.color = color;
    this.price = price;
}
//成员方法
public void run(){
    System.out.println(this.name+"汽车行驶");
}

public void run(int speed){
    System.out.println(this.name+"汽车以"+speed+"速度行驶");
}

public class TestCar {
    public static void main(String[] args) {
        Car bm = new Car();
        bm.name = "宝马";
        bm.color = "黑色";
        bm.price = 200000;
        bm.run();

        Car bc = new Car("奔驰","红色",300000);
        bc.run();

        Car dz = new Car("大众","红色");
        dz.run(120);
    }
}

对象与引用

java中除了8种基本类型外，其余的都是引用类型。

基本类型：使用关键字声明，结构简单。

int a = 10;

引用类型：类、数组、结构……

类是符合类型，比较复杂可以定义更多的东西

Car dz = new Car("大众","红色");

Car ad = dz; //创建了2个对象  ad、dz指向相同的对象
ad.name = "奥迪";
System.out.println(ad.name);  //奥迪
System.out.println(dz.name);  //奥迪
System.out.println(bc.name);  //奔驰

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Desjw9nZ-1642687013933)(E:\Java学习\2022-1-17java第三章面向对象2\课件\对象创建内存图.png)]

值传递与引用传递

严格来讲，参数传递只有值传递

为了基本类型和引用类型区分：分为值传递和引用传递

值传递特指基本类型。

方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

public class TestValue {
    public static void main(String[] args) {
        int a = 10;
        TestValue t = new TestValue();
        t.test(a);
        System.out.println("a:"+a);  //a的值是多少？ 10
    }

    /*
        基本类型就是值传递
    */
    public void test(int b){
        System.out.println("b:"+b);  //10 
        b = 20;
    }
}

引用传递对应的是引用类型。

也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

public class TestValue {
    public static void main(String[] args) {
        TestValue t = new TestValue();
        Car car1 = new Car();
        car1.name = "奔驰";
        t.test(car1);
        System.out.println("car1.name:"+car1.name);  //大众
    }

    /*
        引用类型  传递的不是对象本身，而是传递对象的引用地址
    */
    public void test(Car car2){
        System.out.println("car2.name:"+car2.name);  //奔驰
        car2.name = "大众";
    }
}

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。

this关键字

this关键字代表当前正在使用的对象。

static关键字

static被称为静态，可以用来修饰类的属性，方法，代码块，内部类。

随着类的加载而加载
优先于对象存在
修饰的成员，被所有对象共享
可不创建对象，直接被类调用。

静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。

public class Aodi {
    /*
       Aodi 他们的名字应该都叫奥迪,在定义类的时候直接对其进行赋值。
            型号和价格是不一样的
    */
    String model;
    float price;
    //static修饰的成员变量在内存中只有一份，所有对象可以共享，随着类的加载而加载，通过类名调用
    static String name = "奥迪";
}

public class TestAodi {
    public static void main(String[] args) {
        
        System.out.println(Aodi.name); //可以不创建对象，直接被类调用

        Aodi a8 = new Aodi();
        a8.model = "a8";
        a8.price = 300000;
        System.out.println(Aodi.name+":"+a8.model+":"+a8.price); //可通过类名直接调用

        Aodi q8 = new Aodi();
        q8.model = "q8";
        q8.price = 500000;
        System.out.println(q8.name+":"+q8.model+":"+q8.price);
    }
}

static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用。

在static方法内部只能访问类的static属性，不能访问类的非static属性，static属性先加载。

静态的成员随着类加载后，就可以使用了。而非静态的必须要创建对象后，才可以使用。

//static 修饰的方法是静态方法，属于类，只能使用静态的成员变量。
public static void run(){
    System.out.println(name);
    System.out.println(this.model); //报错  非静态创建对象后才能使用
}

//可以直接使用
Aodi.run();

代码块

代码块在类中声明，类似于没有名称的方法体。

类加载时就自动执行。

分为实例代码块，静态代码块。

实例代码块：在创建对象时调用。
静态代码块：在类加载时调用，只调用一次（因为类只加载一次）。

{
    System.out.println("实例代码块1");
}
{
    System.out.println("实例代码块2");
}
/*
   以后，把在类加载时，就需要自动执行的内容，写在静态代码块中，只执行一次
*/
static {
    System.out.println("静态代码块1");
}
static {
    System.out.println("静态代码块2");
}

public class Test {
    public static void main(String[] args) {
        new Aodi();  //第一次创建对象，并加载类
        new Aodi();  //第二次创建对象，不加载类
    }
}

//静态代码块有限执行，且执行一次。
//原因：类比对象优先加载，且只加载一次
/*输出结果为：
静态代码块1
静态代码块2
实例代码块1
实例代码块2
实例代码块1
实例代码块2
*/

包

包：为了更好的管理java中的类，创建包来进行管理，用于区别类名的命名空间。

包在硬盘上来讲其实就是文件夹，但在java项目中和文件是有区别的，是作为类的路径存在的。

directory：文件夹 package：包

同一个包下，不会有两个相同的类名。

包的作用：

避免类重名（区别重名类）

package Day3;

//import  使用其他包中的类时，需要导入其他包中的类（同一个包的类、java.lang包不用导入）
import Day2.Car;

public class Test {
    public static void main(String[] args) {
        String s;  //java.lang包
        /*
           Car是类的简称  类的全称（全类名）Day2.Car
        */
        new Car();  //Day2包里的Car
        new Day1.Car();  //Day2中的Car已导入，只能使用全类名


    }
}

按照不同功能管理类

eg. 控制层、数据访问层、业务逻辑处理层、公共类、配置类、工具类等
控制访问权限

访问权限修饰符（见下个标题）

包的命名规范：在包名中，可以使用 . 号来区分包的级别，包名一般情况下是小写。

第一级指该项目的类型，如com（商业公司）,org（组织）,gov（政府）,edu（教育）等，
第二级指项目所开发或者运行的公司名称，如：oracle,sun,huawei 等
第三级指项目的名称，如：bcms,oa,erp,cms等
第四级指项目模块的名称，如：bean,action,exception等

访问权限修饰符

按照不同功能管理类

控制访问权限

Java语言有四个权限访问修饰符，权限从大到小依次为：

public ：公共权限修饰类、属性、方法。可以被任意类访问
protected：受保护的权限修饰属性、方法。可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
default：同包权限修饰类、属性、方法。只能被同包的类访问
private：私有权限修饰属性、方法。只能在本类中访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ubA98y4u-1642687013940)(E:\Java学习\访问权限修饰符.png)]

package com.ffyc.javaoop.day3;
    /*
       类  只能用public 和 默认 修饰
    */
public class Demo {
    /*
       public 公共权限       在任何类中都可以访问到
       protected 受保护权限  在自己类中，同包的其他类中，不同包的子类中可以访问到
                 默认权限    在自己类中，同包的其他类中
       private   私有权限    只能在自己类中访问到
    */

    public String pubName;
    protected String proName;
    String delname;  //默认
    private  String priName;

    protected  void test1(){

    }
    protected void test2(){


    }
    void test3(){

    }
    private void test4(){
        
    }
    
    public void test(){
        Demo d = new Demo();
        d.pubName = "p";
        d.proName = "po";
        d.delname = "";
        d.priName = "pi";
    }
}

package com.ffyc.javaoop.day3.child;

import com.ffyc.javaoop.day3.Demo;

public class ChildDemo extends Demo{
    public void test(){
        Demo d = new Demo();
        d.pubName = "a";  //只剩下公共的

        ChildDemo cd = new ChildDemo();  //默认权限和私有权限仍访问不到
        cd.proName = "1";
        cd.pubName = "q";
    }
}

package com.ffyc.javaoop.day3;

public class Demo1 {
    public void test(){
        Demo d = new Demo();
        d.pubName = "a";
        d.proName = "p";
        d.delname = "d";
    }
}

面向对象的三大特征

面向对象语言的三大特征：

封装
继承
多态

封装

封装：将某个功能封装成一个方法。eg. 写了一个工具类，定义好了几个常用的方法。

面向对象中的封装：是隐藏（访问权限修饰符 private、protected、默认、public……）将类中的某些信息不对外开放。

private String name;  //属性私有化，只是封装的一种表示

封装特点：

隐藏类的实现细节
方便加入控制语句
只能通过规定方法访问
方便修改实现

package com.ffyc.javaoop.day3.pack;

public class Person {
    private String name;
    private int age;

    public void setAge(int age){
        if(age>18){
            this.age = age;  //this.age对象中的age
        }
    }

    public int getAge(){
        return age;
    }

    //setXXX方法就是为私有属性提供访问的公共方法
    public void setName(String name){
        //方便加入控制语句
        if(name.length()>3 && name.length()<6){
            this.name = name;
        }
    }

    public  String getName() {
        return this.name;
    }

}

package com.ffyc.javaoop.day3.pack;

public class TestPerson {
    public static void main(String[] args) {
        //private 将name属性隐藏，在其他类中无法访问
        Person zs = new Person();
//        zs.name = "fadsf";
        zs.setName("fsdfj");
        System.out.println(zs.getName());
    }
}

单例模式：（模式就是模板，解决一种问题，就有）

单例模式解决在一个程序中，只能让一个类创建一个对象。

package com.ffyc.javaoop.day3.pack;

public class WindowDemo {
    static WindowDemo windowDemo = null;

    /*
       将构造方法私有化，这样在其他类中就不能创建对象了
    */
    private WindowDemo(){

    }

    //向外提供一个方法，用来创建唯一的一个对象，并返回此对象
    public static WindowDemo getWindowDemo(){
        //单例模式
        //第一次已经创建，第二次windowDemo不为null，因而直接返回windowDemo
        if(windowDemo == null){
            windowDemo = new WindowDemo();
        }
        return windowDemo;
    }
}

package com.ffyc.javaoop.day3.pack;

public class TestWindow {
    public static void main(String[] args) {
//        new WindowDemo(); 构造方法私有，无法创建对象
        System.out.println(WindowDemo.getWindowDemo());
        System.out.println(WindowDemo.getWindowDemo());
    }
}

继承

继承：是面向对象程序设计不可缺少的设计思想，实现代码可重用，提高代码可扩展性的主要途径。

什么时候使用继承：

可以把一些共有属性行为抽取出来，创建一个父类，让其他类继承即可。

eg. 猫是动物狗是动物是属于同一类大小的关系

基本语法：

父类 —> 子类
子类 extends 父类 extends Object

public class Animal extends Object{
    private String name;
    private int age;

    public void eat(){
        System.out.println(this.name+"动物吃东西");
    }

    //get set方法 专属用于私有属性赋值
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


/*
   子类继承父类  使用extends关键字
   一个类只能直接继承一个父类，但是可以间接继承
*/
public class Dog extends Animal{

}


public class AngelDog extends Dog{
    //扩展字节的功能，同时重复调用父类的功能
    public void fly(){
        System.out.println("哮天犬会飞");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("可可");
        dog.setAge(5);
        System.out.println(dog.getName());
        System.out.println(dog.getAge());
        dog.eat();
    }
}

继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力。

在JAVA中使用extends关键字来表示继承关系。
JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。
继承之后子类可以调用父类的所有非私有属性和非私有方法

符合is-a关系的设计,使用继承。将子类共有的属性和行为放到父类中。

继承的传递性：

C类从B类继承,B类又从A类继承，那么C类就具有B类和A类的所有非私有属性和非私有方法。
当一个没有显示的继承任何一个类时，那么jvm会默认让类继承Object类，Object（java.lang包）是所有类的基类（父类/超类）。

继承中的构造方法：

在创建对象，调用构造方法时，子类的构造方法会默认去调用父类的构造方法。因为要先初始化父类，子类才可以去使用父类中的属性行为。

构造方法可以用来初始化
使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行。

如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。

public class AngelDog extends Dog{
    //扩展字节的功能，同时重复调用父类的功能
    public void fly(){
        System.out.println("哮天犬会飞");
    }

    public AngelDog(){ //super表示父类，并不是父类对象
        //super（）调用父类构造方法，默认存在，可以不写，在子类构造方法的第一行
        //如果显示的调用，必须在第一行调用
        super(); 
        System.out.println("AngelDog类无参构造");
    }
}

super关键字用途：

使用super关键字访问父类成员。
用super.成员变量名来引用父类成员变量。
用super.方法名（参数列表）访问父类的方法。
用super.构造方法(参数列表)访问父类构造方法。
注：不要把super误认为是父类对象.在创建子类对象时, 不会创建父类对象，只会将父类中的信息加载到子类对象中存储。
```
public AngelDog(){  //super表示父类
    super();
    System.out.println("AngelDog类无参构造");
    super.eat();
}
```

方法的重写：当父类的方法实现不能满足子类需求时，可以对方法进行重写（override）。

重写要求：与类中的方法名一致，参数、返回值一致，访问权限等于或大于父类权限。

@Override 是java中的注解标签用来标记的。作用在方法上，用来表示此方法是从父类中重写而来的，在编译期间检测语法格式。

/*
神犬吃东西实现方式与其他动物不一样，那么就可以在哮天犬类中重写（覆盖）Animal类中的eat（）方法  方法重写
重写的要求：与父类中的方法名一致，参数、返回值一致  访问权限等于或大于父类权限

@Override 是java中的注解标签，用来标记的
@Override 作用在方法上，表示此方法是从父类中重写而来的，在编译期间检测语法格式。
*/
@Override
public void eat(){
    System.out.println("哮天犬坐着吃饭");
}

多态

同一种事物，在不同时刻表现不同的状态。

前提：要有继承（包括接口实现），要有方法重写，父类的引用指向子类对象。

//父类的引用指向子类对象
Animal dog1 = new Dog();
Animal cat1 = new Cat();
Object d = new Dog();

Dog dog = new Dog();  //Dog的引用指向Dog对象
Cat cat = new Cat();

编译期间：写代码时就是编译期间，Animal dog1 在编译期间是Animal类型。

运行期间：run运行程序。Animal dog1 在运行期间是Dog类型。

对于成员方法来讲，编译看左边，运行看右边。

对象在运行时才创建。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JD3FJj9a-1642687013942)(E:\Java学习\2022-1-19java第三章面向对象4\课件\Snipaste_2022-01-19_11-26-24.png)]

对于静态方法来讲，编译和运行都看左边。

对于成员变量来讲，编译和运行都看左边。

多态：提高了程序的扩展性，因而子类类型向上转为父类类型。

多态存在不足：使用多态时，不能访问子类中特有的方法，因为已经向上转为父类类型，编译期间不能调用子类特有方法。

解决：需要向下转型，转型前最好判断类型，使用instanceof关键字来判断。

public class Test2 {
    public static void main(String[] args) {
        /*
           创建一个喂不同动物，动物吃东西的功能。
           不用多态来实现,扩展性不好。
        */
        Dog dog = new Dog();
        Cat cat = new Cat();

        Test2 t = new Test2();
        t.feedDog(dog);
        t.feedCat(cat);
    }

    public void feedDog(Dog dog){
        dog.eat();
    }

    public void feedCat(Cat cat){
        cat.eat();

    }
}

public class Test3 {
    public static void main(String[] args) {
        /*
           创建一个喂不同动物，动物吃东西的功能。
           用多态来实现。
           把子类类型上升为父类类型，可以用父类类型表示所有的子类对象  （多态的好处）
        */
        Animal dog = new Dog();
        Animal cat = new Cat();

        Test3 t = new Test3();
        t.feedAnimal(dog);
        t.feedAnimal(cat);
    }

    public void feedAnimal(Animal animal){
        animal.eat();
//        animal.play();  animal中无play（）方法因而报错，需要向下转型
//        Dog dog = (Dog) animal;
//        dog.play();  //Cat类中无play（）因而cat报错
        //向下类型转换时，需要做一个判断
        //关键：instanceof  检测animal在运行时，实际的类型是否为Dog，如果是返回true，否则返回false。
        if(animal instanceof Dog){
            Dog dog = (Dog)animal;
            dog.play();
        }
    }
}

抽象类

抽象就是一个概念，不是具体的。

抽象方法：

抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。
抽象方法必须用abstract关键字进行修饰。
在一些体系结构比较庞大的体系中，可以将顶层的类中的方法定义为抽象的。

抽象类：

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。

用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类

/*
   如果一个类中有抽象的方法，name这个类必定是抽象类
   但是抽象类中不一定有抽象方法
   抽象类就是一个不完整的类，里面有抽象方法
   抽象类因为没有具体实现的抽象方法，所以抽象类不能创建对象，除了不能创建对象外，其他功能和正常类一致。
*/
public abstract class Animal {
    private  String name;
    int age;

    /*
       abstravt 修饰的方法是抽象方法，可以没有具体的实现
       只是作为一个功能的定义，在顶层类中往往只需要定义功能即可，让其他类去实现
    */
    public abstract void eat();

    public Animal(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

/*
   一个类继承了抽象类，可以继续声明成抽象类
*/
public abstract class Dog extends Animal{
    private String type;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

/*
   哮天犬就是一个具体的类，重写父类中的抽象方法
*/
public class AngelDog extends Animal{
    @Override
    public void eat(){
        System.out.println("哮天犬坐着用餐");
    }
}

public class Test {
    public static void main(String[] args) {
        AngelDog xtq = new AngelDog();
        xtq.setAge(1000); //非抽闲的依旧可以调用
        xtq.eat();
    }
}

抽象类特点：

抽象类不能被实例化，但可以有构造方法。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。

final关键字

final用于声明属性、方法和类。

属性：final修饰的属性是常量，值不可以改变，必须要初始化赋值。

//在定义时，直接为其赋值，值不可以改变。建议使用static赋值，在整个内存中值只有一份。
static final int num = 100;
//在定义时，没有为常量赋值，必须在构造方法中赋值。在每一个对象中，都可以拥有一个常量。
final int count;
//创建一个有参的构造方法
public finalDemo(int count) {
    this.count = count;
}

public void test(){
//        num = 10;  //final修饰无法赋值
    new String("abc");
    //只有创建对象时，在其构造方法中为其赋值。
    new finalDemo(10);
    new finalDemo(20);
}

方法：final修饰的方法不能被子类重写，不能修饰抽象的方法。
```
public final void test(){
    //final修饰的方法不能被子类重写
}
```
类：修饰后的类不能被继承，final不能修饰抽象类、接口。

接口

接口（USB接口）：专注于功能的设计，而不是实现。让其他类去具体实现即可。与抽象类类似，但有区别。

基本语法：

接口中所有属性默认为：public static final 静态常量
抽象方法默认：public abstract 修饰
jdk8以后添加了静态方法，接口可以直接调用。
jdk8以后添加了默认方法，通过子类调用。

public interface Myinterface {

//    public static final int NUM = 10; //必须赋值  NUM常量   前面默认有public static final
    int NUM = 10;  //接口种定义的属性默认是静态常量

//    public abstract void eat();  前面默认是public abstract修饰
    void eat();
    void sleep();

    //java8之后，新增加两种方法（静态方法，默认方法）
    //静态方法 接口自己调用
    public static void test1(){
        System.out.println("test1 "+NUM);
    }
    //默认方法 是让子类重写，或者让子类调用
    public default void test2(){
        System.out.println("test2");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Myinterface.NUM);
        Myinterface.test1(); //静态方法
//        Myinterface.test2();  默认方法无法直接调用
    }
}

接口的继承：

一个类只能直接继承一个类
一个类可以实现多个接口
一个接口可以继承多个接口

public class MyinterfaceImpl extends Object implements Myinterface,InterfaceC{
    //MyinterfaceImpl :Myinterface类的名字，Impl接口的实现

    //静态方法不能重写，默认方法可重写可不重写
    /*
       一个类实现接口，要么将此类继续声明为抽象类；要么重写接口中的所有抽象方法。
    */
    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }
    //默认方法可重写可不重写
    @Override
    public void test2() {

    }
}

public interface Myinterface extends InterfaceA,InterfaceB{}

接口的特性：

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字
接口中方法可以是抽象的,静态的,默认的
接口中声明的属性默认为 public static final 的
接口不是被类继承了，而是要被类实现
接口不能实例化对象,无构造方法
一个类可以实现多个接口
与继承关系类似，接口与实现类之间存在多态性
一个接口能继承其它多个接口
当类实现接口的时候，类要实现接口中所有的抽象方法。否则，类必须声明为抽象的类

抽象类和接口的区别

相同点：

都不能创建对象
都可以表示多态性

不同点：

接口
- 接口不能有构造方法
- 不能有成员变量
- 不能有成员方法，只有静态方法、默认方法
抽象类
- 能有构造方法
- 能有成员变量

什么时候使用接口，什么时候使用抽象类：

public abstract class Animal {
    private String name;

    public Animal(){

    }

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

    public abstract void eat();

    public abstract void sleep();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Bird extends Animal implements CanFly,CanCry{
    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void cry() {

    }

    @Override
    public void fly() {

    }
}

public class Dog extends Animal{
    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }
}

public interface CanCry {
    void cry();
}

public interface CanFly {
    void fly();
}

public class Test {
    public static void main(String[] args) {
        Animal bird = new Bird();
        CanFly b = new Bird();  //接口也可以作为父类类型来存在
        CanCry c = new Bird();
//        CanCry d = new Dog();  Dog没有CanCry的接口，无法实现
    }
}

这篇关于03Java面向对象的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程