01面向对象

1.1面向过程与面向对象的区别

1.编程思想不同

          面向过程：是一种以过程为中心的编程思想。都是以什么正在发生为主要目标进行编程。
　　   面向对象：是一类以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，而对象是程序运行时刻的基本成分。　

2.特点不同

　　　面向过程：就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

　　　面向对象：是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。　　　

3.优势不同

　　　面向过程：不支持丰富的“面向对象”特性（比如继承、多态），并且不允许混合持久化状态和域逻辑。
　　　面向对象：在内部被表示为一个指向一组属性的指针。任何对这个对象的操作都会经过这个指针操作对象的属性和方法。

1.2面向对象三大特性

继承：

封装：

多态：

1.3类与对象的概念

什么是对象？
         万物皆对象。它包括现实中客观存在的事物，也包括抽象的时间、规则、思维。简单点说，对象具有状态、行为和标识。

什么是类？
         具有相同特性和行为的对象组成的集合就是类，JAVA实际中的类就是指一个数据类型。

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类的实例化结果就是对象，而对一类对象的抽象就是类，类描述了一组有相同属性和相同方法的对象。

如：

学生 — 张三 班级—181                                    “张三”，“181”是具体存在的，他们都是对象 学生又包含 学号、姓名、性别、地址，班级，这是一个学生类，学号、姓名、性别、地址，班级是类的属性。 类=属性+方法 属性来源于类的状态，而方法来源于动作 1.4类的定义 在Java中的定义：         修饰符  class  类名  extends 父类名  implements  接口名称{                         类体（属性和方法） } 代码：  

public class Student{
    int num;
    String name;
    int age;
}

1.5对象的创建和使用

Student stu = new Student();

stu.name = ”张三“;  //对成员变量进行赋值

一个类可以创建 N 个对象，成员变量只属于当前的对象（只属于对象，不属于类），只有通 过对象才可以访问成员变量，通过类不能直接访问成员变量

1.6面向对象的封装性

封装就是 封装属性 ，让外界知道这个类的状态越少越好。使用 private 关键字， 属性只能通过方法访问。

public class Student{
    private int num;
    private String name;
    private int age;
}

而此时访问属性，需要使用get，set方法：

class Student{
    private int num;
    private String name;
    private int age;
//get方法
    public int getNum() {
        return num;
    }
//set方法
    public void setNum(int num) {
        this.num = num;
    }

    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;
    }
}

在main函数中调用get,set方法：

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(22);
        System.out.println(stu.getAge());
    }
}

得到年龄属性值为22

1.7构造函数，构造方法，构造器

构造方法主要用来创建类的实例化对象，可以完成创建实例化对象的初始化工作，构造方法可以重载。 声明格式：         构造方法修饰词列表（public 、 proteced 、 private ）  类名 （方法参数列表）

 构造方法特点：

        构造方法名与类名一致

        没有返回值，也不能有void关键字

        任何类都有构造方法，如果没有显式定义出来，系统会为该类定义一个默认构造器（无参构造方法）

代码：

class Student{
    int num;
    String name;
    int age;
    
    //无参构造器
    public Student(){
        
    }
    //有参构造器
    public Student(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }
}

// 调用带参数的构造方法对成员变量进行赋值

public class Test13 {
    public static void main(String[] args) {
        Student stu = new Student(181,"张三",22);
        
    }
}

1.8对象和引用

1.8.1Java 内存的主要划分

1.8.2Test.java内存表示

第一步，执行 main 方法，将 main 方法压入栈，然后 new Student 对象

// 创建一个对象 Student s = new Student(); 第二步，对 student 赋值 s.num = 181; s.name = "张三"; s.age = 22;

 

 1.9this关键字

this 关键字指的是当前调用的对象，如果有 100 个对象，将有 100 个 this 对象指向各个对象 this关键字可以使用在：         局部变量和成员变量重名时，使用this指定调用成员变量         通过this调用另一个构造方法 代码：   //调用成员变量

class Student{
    int num;
    String name;
    int age;
    public Student(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }
}

//调用另一个构造方法

public class Test13 {
    public static void main(String[] args) {
        Student stu = new Student(182,"李四");
        System.out.println(stu.num + " " +stu.name + " " +stu.age);
    }
}

class Student{
    int num;
    String name;
    int age;

    public Student(int num,String name){
        this(181,"张三",22);
    }

    public Student(int num, String name, int age) {
        this.num = num;
        this.name = name;
        this.age = age;
    }
}

1.10static关键字 1.10.1 采用静态变量实现累加器 static 声明的变量会放到方法区中，static 声明的变量只初始化一次，加载类的时候初始化，如果多个静态变量，会按照静态变量在类中的顺序进行初始化。 1.10.2静态方法中访问实例变量、实例方法或this 关键字 静态方法中是不能直接调用实例变量、实例方法和使用 this 的。

public class Test13 {
    public static void main(String[] args) {
        //可以直接调用
        method();
        //可以采用类名+方法调用
        Test13.method();
    }
    public static void method(){
        System.out.println("method");
    }
}

1.10.3main方法

public ：表示全局所有，其实就是封装性 static ：静态的，也就是说它描述的方法只能通过类调用 main ：系统规定的 String[] args 参数类型也是系统规定的

 

1.11类的继承          继承是实现软件可重用性的重要手段，如：A 继承 B，A 就拥有了 B 的所有特性         java 中只支持类的单继承，也就是说 A 只能继承 B，A 不能同时继承 C java 中的继承使用 extends 关键字。 语法格式：         [修饰符] class 子类 extends 父类 { 代码：

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

class Bird extends Animal{
    public void fly(){
        System.out.println("Bird is");
    }
}

1.12方法的覆盖  override

又被称为方法重写
什么时候使用方法重写：
    父类中的方法已经无法满足当前子类的业务需求，子类有必要将父类中继承过来的方法进行重写
建议方法重写的时候尽量进行复制粘贴
方法重写发生在具有继承关系的父子类之间
方法重写的时候，返回值类型相同，方法名相同，参数列表相同
覆盖只针对方法，不谈属性

代码：

public class Test05 {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.move();
        Bird b = new Bird();
        b.move();
    }
}

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

class Bird extends Animal{
    public void fly(){
        System.out.println("Bird is");
    }

    @Override
    public void move() {
        //super.move();
        System.out.println("覆盖父类中的方法");
    }
}

多态其实就是多种状态，overload（重载）是多态的一种，属于编译期绑定，也就是静态绑 定（前期绑定），override 是运行期间绑定（后期绑定）。 多态存在的条件：         有继承         有覆盖         父类指向子类的引用

 

 静态方法不存在多态的概念，多态和成员方法相关，静态方法只属于某一个类，声明的是那个一个类就调用的是哪一个类的静态方法和子类没有关系,不像覆盖了成员方法，new 谁调谁，为什么覆盖成员方法可以构成多态（多种状态），主要是运行期的动态绑定（动态绑定构成多态），静态绑定的含义是在编译成 class 文件（字节码）的时候已经确定该调用哪个方法。 1.13super关键字 super 关键字的作用：         调用父类的构造方法         调用父类的成员方法 需要注意： super 只能应用在成员方法和构造方法中，不能应用在静态方法中（和 this 是一 样的），如果在构造方法中使用必须放在第一行 为什么会有 super 关键字？         因为子类必须要调用父类的构造方法，先把父类构造完成，因为子类依赖于父类，没有父，也就没有子         有时需要在子类中显示的调用父类的成员方法 构造方法不存在覆盖的概念，构造方法可以重载 super 需要 放到构造函数的第一行语句 代码： // 调用默认构造方法

public class Test05 {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.move();
        Bird b = new Bird();
        b.move();
    }
}

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

class Bird extends Animal{
    public void fly(){
        System.out.println("Bird is");
    }

    @Override
    public void move() {
        //调用父类的无参的构造函数
        super.move();
        System.out.println("覆盖父类中的方法");
    }
}

//调用带参数的构造方法  

public class Test05 {
    public static void main(String[] args) {
        Animal a = new Animal(181,"张三");
        
        Bird b = new Bird(182,"李四",22);
        
    }
}

class Animal{
    int num;
    String name;

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

class Bird extends Animal{
    int age;
    public Bird(int num, String name,int age) {
        //手动调用调用带参数的构造函数
        super(num, name);
        this.age = age;
    }
}

//采用super 调用父类的方法

public class Test05 {
    public static void main(String[] args) {
        Bird b = new Bird();
        b.move();
    }
}

class Animal{
    int num;
    String name;
    public void move(){
        System.out.println("Animal is");
    }

}

class Bird extends Animal{
    public void fly(){
        //采用 super 调用父类的方法 
        super.move();
    }

}

 1.14final关键字

final是一个关键字，表示最终的，不可变的
final修饰的类无法被继承，修饰的方法无法被覆盖
修饰的变量一旦被赋值后，不可重新赋值
final修饰的实例变量通常和static联合使用，称为常量

如果修饰的引用，那么这个引用只能指向一个对象， 也就是说这个引用不能再次赋值，但被指向的对象是可以修改的 代码：

public class Test06 {
    public static void main(String[] args) {
        Person p1 = new Person();
//可以赋值
        p1.name = "张三";
        System.out.println(p1.name);
        final Person p2 = new Person();
        p2.name = "李四";
        System.out.println(p2.name);
//不能编译通过
//p2 采用 final 修饰，主要限制了 p2 指向堆区中的地址不能修改(也就是 p2 只能指向一个对象)
//p2 指向的对象的属性是可以修改的
        p2 = new Person();
    }
    }


class Person {
    String name;
}

1.15抽象类

 

         在 java 中采用 abstract 关键字定义的类就是抽象类，采用 abstract 关键字定义的方法就是抽象方法         抽象的方法只需在抽象类中，提供声明，不需要实现         如果一个类中含有抽象方法，那么这个类必须定义成抽象类         如果这个类是抽象的，那么这个类被子类继承，抽象方法必须被重写。如果在子类中不复写该抽象方法，那么必须将此类再次声明为抽象类         抽象的类是不能实例化的，就像现实世界中人其实是抽象的，张三、李四才是具体的         抽象类不能被 final 修饰         1.16接口 implements          接口我们可以看作是抽象类的一种特殊情况，在接口中只能定义抽象的方法和常量         在 java 中接口采用 interface 声明         接口中的方法默认都是 public abstract 的，不能更改         接口中的变量默认都是 public static final 类型的，不能更改，所以必须显示的初始化         接口不能被实例化，接口中没有构造函数的概念         接口之间可以继承，但接口之间不能实现         接口中的方法只能通过类来实现，通过 implements 关键字         如果一个类实现了接口，那么接口中所有的方法必须实现         一类可以实现多个接口 代码：

public class Test10 {
    public static void main(String[] args) {
        MyMath my = null;
        System.out.println(my.a);
        My m = new My();
        System.out.println(m.dosome(10));
    }
}
interface MyMath{
    int a = 10;
    int dosome(int a);
}

class My implements MyMath{
    public int dosome(int a){
        return a;
    }
}

 

1.18多态

多态其实就是多种状态的含义，如我们方法重载，相同的方法名称可以完成不同的功能，这 就是多态的一种表现，此时成为静态多态。多态的条件是：有继承或实现，有方法覆盖或实现，父类对象(接口)指向子类对象 1.19Object类         Object 类是所有 Java 类的根基类         如果在类的声明中未使用 extends 关键字指明其基类，则默认基类为 Object 类 如：

public class User {
………..
}
相当于
public class User extends Object {
………..
}

1.20finalize

         垃圾回收器（Garbage Collection），也叫 GC，垃圾回收器主要有以下特点：         当对象不再被程序使用时，垃圾回收器将会将其回收         垃圾回收是在后台运行的，我们无法命令垃圾回收器马上回收资源，但是我们可以告诉他，尽快回收资源（System.gc 和 Runtime.getRuntime().gc()）         垃圾回收器在回收某个对象的时候，首先会调用该对象的 finalize 方法         GC 主要针对堆内存         单例模式的缺点 1.21包和import 包其实就是目录，特别是项目比较大，java 文件特别多的情况下，我们应该分目录管理,在 java 中称为分包管理，包名称通常采用小写 1、包最好采用小写字母 2、包的命名应该有规则，不能重复，一般采用公司网站逆序， 如：com.LQ.项目名称.模块名称 com.LQ.exam package 必须放到 所有语句的第一行，注释除外 采用 import 引入需要使用的类 可以采用 * 通配符引入包下的所有类 1.22 JDK 常用开发包         java.lang，此包 Java 语言标准包，使用此包中的内容无需 import 引入         java.sql，提供了 JDBC 接口类         java.util，提供了常用工具类         java.io，提供了各种输入输出流 1.23访问控制权限

1.24内部类

在一个类的内部定义的类，称为内部类 内部类主要分类：         实例内部类         局部内部类         静态内部类

 

1.24.1实例内部类

        创建实例内部类，外部类的实例必须已经创建         实例内部类会持有外部类的引用         实例内部不能定义 static 成员，只能定义实例成员 代码：

public class Test14 {
    private int a;
    private int b;
    Test14(int a, int b) {
        this.a = a;
        this.b = b;
    }
    //内部类可以使用 private 和 protected 修饰
    private class Inner1 {
        int i1 = 0;
        int i2 = 1;
        int i3 = a;
        int i4 = b;
    //实例内部类不能采用 static 声明
    //static int i5 = 20;
    }
    public static void main(String[] args) {
        Test14.Inner1 inner1 = new Test14(100, 200).new Inner1();
        System.out.println(inner1.i1);
        System.out.println(inner1.i2);
        System.out.println(inner1.i3);
        System.out.println(inner1.i4);
    }
}

1.24.1静态内部类

        静态内部类不会持有外部的类的引用，创建时可以不用创建外部类         静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

 

代码：

public class Test15 {
    static int a = 200;
    int b = 300;
    static class Inner2 {
        //在静态内部类中可以定义实例变量
        int i1 = 10;
        int i2 = 20;
        //可以定义静态变量
        static int i3 = 100;
        //可以直接使用外部类的静态变量
        static int i4 = a;
        //不能直接引用外部类的实例变量
//int i5 = b;
//采用外部类的引用可以取得成员变量的值
        int i5 = new Test15().b;
    }
    public static void main(String[] args) {
        Test15.Inner2 inner = new Test15.Inner2();
        System.out.println(inner.i1);
    }
}

 

1.24.3局部内部类

        局部内部类是在方法中定义的，它只能在当前方法中使用。和局部变量的作用一样局部内部类和实例内部类一致，不能包含静态成员 代码：

public class Test16 {
    private int a = 100;
    //局部变量，在内部类中使用必须采用 final 修饰
    public void method1(final int temp) {
        class Inner3 {
            int i1 = 10;
            //可以访问外部类的成员变量
            int i2 = a;
            int i3 = temp;
        }
//使用内部类
        Inner3 inner3 = new Inner3();
        System.out.println(inner3.i1);
        System.out.println(inner3.i3);
    }
    public static void main(String[] args) {
        Test16 innerClassTest03 = new Test16();
        innerClassTest03.method1(300);
    }
}

 1.24.4匿名内部类

是一种特殊的内部类，该类没有名字 代码： // 没有使用匿名类

public class Test18 {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterfaceImpl();
        myInterface.add();
    } }
interface MyInterface {
    public void add();
}
class MyInterfaceImpl implements MyInterface {
    public void add() {
        System.out.println("-------add------");
    } }