Java学习：从入门到精通week2

面向对象思想概述概述Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

1.2特点

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。现实中，描述一类事物：

属性：就是该事物的状态信息。行为：就是该事物能够做什么。

对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为。现实中，一类事物的一个实例：一只小猫。

举例：一只小猫。属性：tom、5kg、2years、yellow。行为：溜墙根走、蹦跶的跑、喵喵叫。

类与对象的关系

类是对一类事物的描述，是抽象的。对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体。

1.3类的定义

事物与类的对比

现实世界的一类事物：属性：事物的状态信息。行为：事物能够做什么。Java中用class描述事物也是如此：成员变量：对应事物的属性成员方法：对应事物的行为。

1.4对象的使用

1.5对象内存图

1）一个对象，调用一个方法内存图

2）两个对象，调用同一方法内存图

3）一个引用，作为参数传递到方法中内存图

1.6成员变量和局部变量区别

2.封装

2.1概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

2.2封装的步骤

1.使用private关键字来修饰成员变量。

2.对需要访问的成员变量，提供对应的一对getXxx方法、setXxx方法

2.3封装的操作——private关键字

private的含义

1.private是一个权限修饰符，代表最小权限。

2.可以修饰成员变量和成员方法。3.被private修饰后的成员变量和成员方法，只在本类中才能访问。

2.4封装优化1——this关键字

2.5封装优化2——构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。小贴士：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

2.6标准代码——JavaBean

javaBean是Java语言编写类的一种标准规范。符合JavaBean的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的set和get方法。

在写完我们需要的成员变量后，再补齐后面的构造方法以及 settergetter是非常麻烦的，所以可以用一下方法解决：

1.点击左上角的Code键，选择里面的Generate

2.根据需要点击对应的选项即可，如第一个是构造方法

二.String类、static关键字、Arrays类、Math类

1.String类

1.1概述

1.2构造方法

注意：只要带上双引号，就是字符串对象。

在编辑页面按住ctrl在点击需要查看的内容可以查看源代码。

1.3字符串常量池

通过new创建的字符串不在字符串常量池里面，故为false。

1.4字符串的相关比较

在进行“==”比较字符串是使用的是地址，如果需要对字符串的内容进行比较可以使用一下方法。

1.a.equals（b）

只有当a，b为相同内容的字符串时才会返回true。

2. a.equalsIgnore（b），不区分大小写（英文字母）

1.5字符串获取方法

1.6字符串截取方法

变的不是字符串，而是地址值，在内存中的字符串已经存在。

1.7字符串的转换方法

2.static关键字

2.1概述

关于static关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

2.2定义和使用格式

类变量

当static修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

类变量：使用static关键字修饰的成员变量。

比如说，基础班新班开班，学员报到。现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，要分配给下一名新同学的学号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。所以，我们可以这样定义一个静态变量numberOfStudent

代码如下

静态方法

当static修饰成员方法时，该方法称为类方法。静态方法在声明中有static，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

类方法：使用static关键字修饰的成员方法，习惯称为静态方法。

调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式如下

2.3静态原理图解

2.4静态代码块

执行结果

说明static代码块只执行一次。

3.数组工具类Arrays

*数组遍历，数组+fori正序排列，数组+forr倒序排列

4.Math类

// 四舍五入

三.继承、super、this、抽象类

1.继承

1.1概述

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

定义

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

好处

1.提高代码的复用性。2.类与类之间产生了关系，是多态的前提

1.2继承的格式

1.3继承后的特点——成员变量

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

如果子类父类中出现重名的成员变量，这时的访问是有影响的。

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super关键字，修饰父类成员变量，类似于之前学过的this。

注意：Fu类中的成员变量是非私有的，子类中可以直接访问。若Fu类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

成员方法重名——重写(Override)

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写。

方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

重写的应用：子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。

注意事项

1.子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

2.子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样

1.5继承后的特点——构造方法

格式和使用

1.6super和this

super和this的使用

访问成员和构造方法

super 父类

this 本类

1.7继承的特点

1.Java只支持单继承，不支持多继承。

2.Java支持多层继承(继承体系）

2.抽象类

2.1抽象类的基本概念

普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。

而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

抽象类的使用原则如下：
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）

四.接口，多态

1.接口：接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK7及以前），默认方法和静态方法（JDK8），私有方法（JDK9）。接口的定义，它与定义类方式相似，但是使用interface关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（implements，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类

1.1，格式 public interface 接口名称{ //接口内容 }

1.2接口的抽象方法

public abstract interface InterfaceAbstract {
    /*抽象方法
    注意：1.接口中的抽象方法必须满足固定关键字，public abstract
          2.这两个关键字可以省略

     */
     abstract void abs1();
    abstract void abs2();
    public void abs3();
    void abs4();
}

1.3接口的使用

接口不能直接使用，需要用一个”实现类”来“实现”该接口。

public class 实现类名称 implements 接口名称{ ...}

注意：与普通抽象类相似，实现类中必须覆盖重写接口类中的所有抽象类。

public  class InterfaceSon implements InterfaceAbstract {
    @Override
    public void abs1() {
    System.out.println("接口执行");
    }
}

不能直接new接口对象使用，而是要使用它的实现类。

如果实现类本身没有覆盖重写接口类中的所有抽象方法，那么他自身也必须是一个抽象类，与抽象类的抽象子类类似。

1.4接口默认方法

//接口默认方法 格式 public default void 默认方法名称（）{...}
public interface InterfaceMoren    {
    public default void de(){
        System.out.println("接口默认方法执行");
        /*接口默认方法可以被实现类覆盖重写
            接口默认方法可以被实现类对象直接调用
         */
    }
    void abs();
}

1.5静态方法

格式 public static void 方法名称(){...}

public interface InterfaceStatic {
    public static void mystatic(){
        System.out.println("静态方法执行");

    }
}

public class InterfaceStatic2{
    public static void main(String[] args) {
        /*注意：不能通过实现类对象的调用使用静态方法，而要通过接口名称调用

         */
        InterfaceStatic.mystatic();
    }
}

如

1.6私有方法

格式 private 返回值类型方法名称（）{..}

静态私有方法 private static 返回值类型方法名称（）{...}

这样的话，只有在接口中才能使用私有类。

1.7.接口中常量的定义

eg:

public static final int NUM_OUT_PU=1;（接口中的常量必须赋值,且标识符必须使用大写，用下画线分隔开）

(前三个符号可省略)

一旦使用final修饰符，说明数值不能改变。

访问：接口名称.常量表示符，如进行打印与运算等操作。

注意：接口没有静态代码块和构造方法！

1.8继承父类并实现多个接口

一个实现类可同时继承多个接口，这是普通类无法实现的

public class InterfaceManyS implements InterfaceMany1,InterfaceMany2 {
    @Override
    public void inter1() {
        System.out.println("接口一执行");
    }

    @Override
    public void inter2() {
        System.out.println("接口二执行");

    }
}

public class InterfaceManyUse {
    public static void main(String[] args) {
        InterfaceManyS a=new InterfaceManyS();
        a.inter1();//接口一执行
        a.inter2();//接口二执行

        }
    }

若在接口中存在重复的抽象方法，则在实现类中只需要覆盖重写一个抽象方法。

如果在实现类中没有覆盖重写所有抽象方法，则该实现类必须是抽象类。

若多个接口中存在相同的默认方法，

!!! 如果一个实现类既继承父类又继承接口，父类与接口出现重复的方法，父类要优先子类执行。

1.9接口之间的多继承

1）子接口继承多个父接口，需要对其所有抽象方法进行覆盖重写

2）子接口在继承多个父接口时，如果多个父接口存在重复的抽象方法，只需要覆盖重写一个即可

3）如果多个父接口存在重复默认方法，则必须对其进行重写，而且要带着default关键字

2.多态

2.1代码中实现多态性，其实就是一句话，父类引用指向子类对象

2.2格式

父类名称对象名=new 子类名称（）；

或 接口名称对象名=new 实现类（）；

2.2多态成员变量的使用

访问：与父类子类相同，对象名称.成员变量，先在子类找，没有的话就向上找，也可通过成员方法间接访问，该方法属于谁则用谁，没有则向上找。

2.3编译看左边，运行看右边

这是成员方法的规则：

public class InterfaceMuitiUse {
    public static void main(String[] args) {
        InterfaceMuitiFu k=new InterfaceMuitiZi();
        k.fu();
        k.method();
        k.zi();//zi（）是子类中的方法，编译不通过，因为编译的是父类，子类中的方法（不是覆盖重写）不能使用。
    }
}

2.4多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。

2.5对象的上转型

父类名称对象名=new 子类名称（）；

右边创建一个子类对象把他当成子类看待，向上转型一定是安全的：小--->大。

2.6对象的向下转型

子类名称对象名=（子类名称）父类对象

将父类对象转型成原来的子类对象

比如已经将一只猫通过多态向上转型为动物，将其再转换为猫的过程就是向下转型，后续便可使用作为猫的子类的特有方法。

如果将猫向上转型成动物，再向下转型成狗，此时编译通过但运行会报错：ClassCastException。

2.7instanceof进行类型判断

五.final、权限、内部类

1.final

1.1final作修饰符修饰类

修饰符 final 返回值类型方法名(参数列表){...}

1.2final修饰方法

修饰符 final 返回值类型方法名 (参数列表){...}

final方法不能被覆盖重写，为最终方法。

1.3final作局部变量

eg int a=1；

a=2；

a的地址值发生改变，a的值改变，若在方法内使用final定义变量b，用过方法的方式改变了变量的值，则b的值改变，地址不变。

1.4final修饰成员变量

注意此处注释掉setter，因为已经在构造方法中对其赋值。

2.权限

2.1四种权限修饰符

3.内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

eg 定义外部类 body，内部类heart，他们的class文件名称分别为

body.class

body$heart.class

成员内部类：

3..1内部类的使用

3.2内部类成员变量的访问

无法在内部类的方法中用super直接访问外部类的变量，因为他们不是继承关系。

局部内部类：

4.1局部内部类

4.2局部内部类的使用

public class InnerJubu {
    public  void out(){
        //在成员方法内部定义一个内部类，然后通过创建内部类对象用对象访问内部类的方
        //法，在main调用外部类的方法便可以间接使用内部类。
        class inner{
            public void in(){
                System.out.println("局部方法执行");
            }
        }
        inner a=new inner();
        a.in();
    }
}