面向对象

1面向对象语法

1.1面向对象和面向过程编程思想

面向过程：解决问题时，关注点是每一个步骤，一步一步实现，直接关注流程

面向对象：以分类的方式进行思考和解决问题，先对整体关系做出分类。

类-----分类

字符串-----String类 关于字符串操作的方法，包装到String类中

数组-------Arrays类 关于数组操作的类

1.2类

类是同一类事物相同属性和行为的合集

类中定义的内容

1.成员变量

类的共有属性称为成员变量

成员变量定义在类中，方法体之外的变量。

成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。 在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。 成员变量在创建对象的时候会从类中复制一份到对象中。 成员变量可以被类中方法、构造方法和特定类的语句块访问。 成员变量的作用范围为整个类体

2.成员方法

3.构造方法

构造方法特征：

每一个类中默认有一个无参的构造方法

构造方法名字必须与类名相同

构造方法没有返回值，不用void修饰

如果一个类中定义了有参的构造方法，默认的无参构造方法会被覆盖，要显示定义

构造方法

作用:在构造方法中为创建的对象初始化赋值, 在创建一个对象的时候，至少要调用一个构造方法。 每个类都有构造方法。如果没有显式地为类定义构造方法，Java将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方法后，默认的无参构造方法即失效。 一个类可以有多个构造方法。 例： public class Car{ public Car(){ } public Car(String name){ // 这个构造方法有一个参数：name } } 例：创建Car类的对象 Car car1 = new Car(); Car car2 = new Car(“宝马”)

方法重载：一个类中有多个名称相同的方法，可以通过类型（String，String，int或String，int，String），个数，顺序区别调用

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

1.3对象与引用

1. Java 语言中除基本类型之外的变量类型都称之为引用类型。

Java中的对象是通过引用对其操作的。

1）右边的“new Car()”，是以Car类为模板,在堆空间里创建一个Car类对象。 2）左边的“Car b m”创建了一个Car类型引用变量。所谓Car类的引用，就是以后可以用来指向Car对象的对象引用。 3）”=”操作符使对象引用指向刚创建的那个Car对象。

2.值传递与引用传递

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

1.4 this

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

1.5 static

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

被static修饰的变量和类一样，在内存中只有一份。

1.6 代码块

代码块在类中声明，类似一个没有名称的方法体(代码块)，代码分实例块和静态块 实例块：每次创建对象时自动调用 { //任何符合语法的Java代码 } 静态块：类加载时自动调用，仅执行一次，与是否创建对象无关。 static { //任何符合语法的Java代码 }

1.7 包

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用：

避免类重名 按照不同功能管理类

控制访问权限

1.8 访问权限修饰符

public:修饰类，成员变量，成员方法 任何地方都可使用

protected：修饰成员变量，成员方法 受保护权限，在自己类和同包类中访问，在不同包的子 类中访问

默认：修饰类，成员变量，成员方法 默认权限，在自己类和同包类中访问

private：修饰成员变量，成员方法 私有权限，只能在自己类中访问

2 面对面对象特征

2.1 封装

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 。

如何隐藏:

使用访问权限修饰符来对类中的信息访问权限进行修饰

1.把成员变量私有化

package fengzhuang;
​
public class Demo1 {
    private String name;
    private int age;
    public Demo1(){
​
    }
    public Demo1( String name,int age){
        if (name.length()<4){
            this.name=name;
        }
    this.age=age;
    }
​
    public void setName(String name) {
        if (name!=null&&name.length()<5) {
            this.name = name;
        }
}
public String getName(){
        return this.name;
          }
​
    public void setAge(int age) {
        if(age>0){
        this.age = age;
        }
    }
​
    public int getAge() {
        return this.age;
    }
}
​

package fengzhuang;
​
public class Test {
    public static void main(String[] args) {
       Demo1 d= new Demo1();
       d.setName("asa123232" );
        System.out.println(d.getName());
        d.setAge(16);
        System.out.println(d.getAge());
    }
}

2.把方法私有化

单例模式

package fengzhuang;
​
public class Demo2{
     /*将构造方法私有化，外界就不能直接访问，也不能随意创建对象
     但外界还是需要这个对象，在类的内部提供一个方法来获取创建的唯一一个对象*/
    private Demo2(){
    }
}

package fengzhuang;
​
public class Test2 {
// 构造方法私有化，所以不能创建一个人新的对象
 /*new Demo2;*/
}
​

2.2继承

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

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

2.在JAVA中使用extends关键字来表示继承关系。

3.JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。

4.继承之后子类可以调用父类的所有非私有属性和非私有方法。

继承的形式

[访问权限修饰符] [修饰符] 子类名 extends 父类名{子类体}

继承的传递性 C类从B类继承,B类又从A类继承 那么C类就具有B类和A类的所有非私有属性和非私有方法 当一个没有继承任何一个类时,jvm会默认让类继承Object类 Object是 java为所有类提供的基类

继承中的构造方法

创建子类对象时，在子类的构造方法第一行会默认调用父类中的构造方法（可以是默认，也可以用super关键字调用），要确保先将父类中的成员进行初始化

方法重写

子类与父类实现方式不同，在子类中将父类的方法完全重写过来，就将父类中的方法实现覆盖掉了，使用子类对象调用时，优先调用自己类中的方法。

在重写父类中的方法时，要求方法的结构与父类中的结构保持一致。

要求参数一致，方法名一致，返回值一致，访问权限大于等于父类权限。

*构造方法中，静态方法不能重写，成员变量不存在重写。

2.3抽象类

抽象类 ：用abstract修饰的类叫抽象类，一个类中包含抽象方法，这个类一定是抽象类

抽象方法： 用abstract修饰的方法叫修饰方法，可以没有方法体，只是用来定义功能，不能调用

子类中的实现方式与父类中的实现方法都不同 ，因此没有必要在父类中实现功能

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类除了不能实例化对象(new)之外，类的其它功能依然存在，成员变量、成员方法和构造方法。 用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

2.4多态

多态形成条件 ：

要有继承（包括接口的实现）(前提条件)

要有重写(前提条件) 父类引用

对非静态的成员方法（编译看左边，运行看右边）

对静态的成员方法，成员变量（编译看左边，运行也看左边）

多态优点 :可以用一个父类表示任意子类（向上转型）

多态存在缺点 ：当子类向上转型为父类类型时，编译期间不能调用子类中自己特有的方法

需要调用子类特有方法时，可以强制转换（instanceof）

2.5 final关键字

final 修饰类，成员变量，成员方法，方法参数

final修饰的类，不能被其他类继承

final修饰成员方法，不能被子类重写

final修饰的方法参数，不能在方法中修改值

final修饰成员变量，值不能改变，是常量

2.6 接口

接口的定义：使用 interface 关键字用来声明一个接口。 [访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n] { 声明常量 抽象方法 静态方法 默认方法 } 接口的使用：类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。 [访问修饰符] class 类名 implements 接口名1，接口名2……{ } 结合继承： [访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

//    接口中定义的成员变量，默认是静态常量；
    public static final   int num=10;
​
//    接口中定义的无方法体的方法，默认为抽象方法；
    public abstract void eat();
                    void sleep();
​
//     jdk8之后添加的静态方法为默认方法；
    public static void test(){
        System.out.println();
    }
//    默认方法是由子类来使用的
    public default void test1(){
        System.out.println();
    }

//一个类可以实现多个接口
public class MyInterfaceimpl implements MyInterface,MyInterfaceA,MyInterfaceB

//一个接口可以继承多个接口
public interface MyInterface extends MyInterfaceA,MyInterfaceB

接口的特性

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