Java学习之路(四)：面向对象

Java中的面向对象

概念：面向对象的原本的意思是“”万物皆对象“”

面向对象思想的特点：

• 是一种更符合我们思想习惯的思想，将复杂的事情简单化
• 使我们角色发生了转换，将我们从执行者变成了指挥者

面向对象的特征：

• 封装（Encapsulation）
• 继承（Inheritance）
• 多态（Polymorphism）

一些专业性的词汇：

• 面向对象的分析（OOA，Object Oriented Analysis）
• 面向对象的设计（OOD，Object Oriented Design）
• 面向对象的编程实现（OOP，Object Oriented Programming）

面向对象的开发或者说面向对象的编程的本质就是不断的创建对象，使用对象，指挥对象做事情，管理和维护对象之间的关系

---

 面向对象的基本概念

　　对象就是指人们要进行研究的世界上的任何事物，从最简单的整数到复杂的飞机...均都可以看做是一个对象，它不仅仅能表示具体的事物，还能抽象的规则、计划或事件

如何描述现实世界的事物

• 属性：就是该事物的描述信息（事物身上的名词）
• 行为：就是该事物能够做什么（事物身上的动词）

Java中最基本的单位是类，Java中是用class来描述一件事物

• 类中有成员变量，就是事物的属性

• 类中有成员方法，就是事物的行为

其实我们学习java是学些什么？就是学习面向对象
    声明类
    声明成员变量
    声明成员方法
    创建对象
    给属性赋值
    使用对象

类和对象的概念

• 类：是一组相关的属性和行为的集合
• 对象：是该类事物的具体体现
• 注意：其实一个class类实例化后就是一个对象了

类、属相和方法的声明

• 类的声明：class关键字，eg：class Student
• 属性的声明：数据类型  属性名，eg：String  name
• 方法的声明：public  返回值类型  方法名（）{ }

//声明一个学生类
//属性：姓名，年龄，性别
//行为：学习，睡觉

class Student{
    String name;
    int age;
    boolean sex;
    public void study(){
        System.out.println("这里是学习方法")
    }
    public void sleep(){
        System.out.println("这里是睡觉方法")
    }
}

类的使用

• 创建对象：类名  对象名 = new 类名（）；
• 给属性赋值：对象名.变量名
• 调用方法：对象名.方法名（）

Java中的垃圾回收机制

Java会自动回收无用的对象占用的内存空间，使该空间可以被程序再次使用，程序员不需要向C语言一样要自己进行释放内存的空间，CFRelease()

成员变量和局部变量之间的区别

• 在类中的位置不同
  • 成员变量：在类之中，方法之外
  • 局部变量：实在方法中定义的
• 在内存中的位置不同
  • 成员变量：在堆内存（成员变量属于对象，对象进堆内存）
  • 局部变量：位于栈内存（局部变量属于方法，方法进入栈内存）
• 声明周期不同
  • 成员变量：随着对象的创建而存在，随着对象的消失而消失
  • 局部变量：对着方法的调用而存在，随着方法的调用完毕而消失
• 初始化的值不同
  • 成员变量：有默认的初始化值
  • 局部变量：没有默认的初始化值，必须定义，赋值然后才能使用

成员变量和局部变量的注意事项：

　　局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则

基本数据类型（传值）和引用数据类型（传地址）有哪些？

1.基本数据类型：byte，short，int，long，float，double，boolean，char

2.引用数据类型：数组（eg：int[]），类（class），接口（interface），枚举

方法的形式参数是一个类名的适合如何调用？

　　如果你看到一个方法形式参数是一个类类型（引用类型）的话，那么调用方法的时候其实需要的是该类的对象。

匿名对象

什么是匿名对象：没有给新创建的对象储存在一个变量里

应用的场景：

　　1.调用方法，仅仅只需要调用一次的时候、

　　2.匿名对象可以作为实际的参数进行传递

---

封装概述：

　　是指隐藏对象的属性和实现细节，仅仅对外提供公用的public访问方式

封装好处：

• 隐藏实现的细节，提供公共的访问方式
• 提高了代码的复用性和安全性

封装原则：

• 封装原则将不需要对外提供的内容都隐藏起来
• 把属性隐藏，提供公共的方法对其访问

Private（私有）关键字

• 是一个权限修饰符
• 可以修饰成员变量和成员方法
• 被其修饰的成员只能在本类中被访问

当成员变量用private修饰表示外界不能访问

this关键字的特点

• 代表当前对象的引用

this的应用场景

• 用来区分成员变量和局部变量的重名

this是和外面调用的变量指向同一个地址的，指的是同一对象。

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

像这样，再构造方法中的应用就是最好的例子。

如果你不加this，你可以试一下，会有很好玩的事情发生。

构造方法Constructor的概述

构造方法的作用：给对象的数据（属性）进行初始化的一个赋值

构造方法的特点：

• 方法名与类名相同（大小也与类名一致）
• 没有返回值类型，注意：void也不要写，什么都不写
• 没有具体的返回值return 

构造方法分为

• 有参构造方法
• 无参构造方法

构造方法的重载：

　　是指方法名相同，与返回值类型无关（构造方法没有返回值），只看参数列表

构造方法的注意事项

• 如果我们没有给出构造方法，那么系统会默认给出一个无参数的构造方法
• 如果我们给出了构造方法，系统将不在提供默认的无参构造方法
• 如果我们声明的有参构造方法，这个时候。如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法。
• 正确的构造方法的格式【public 类名()】

static关键字

static关键字的特点：

• 随着类的加载而加载
• static修饰的东西是优先于对象的存在
• 被类的所有对象共享

共性用静态，特性用非静态

static声明的成员属性可以通过类名进行调用

• 其实其本身也可以通过实例化的对象进行调用
• 推荐使用类名进行调用
• 静态修饰的内容我们一般称之为：与类相关的类成员

注意事项：

• static可以用来修饰属性，也可以用来修饰方法
• 在静态方法中是没有this关键字的
  • 静态是随着类的加载而加载的，this则是随着对象的创建而进行创建的
  • 静态比对象要优先
• 静态方法只能访问静态的成员变量和静态的成员方法
• 非静态的方法可以访问静态的成员变量和静态的成员方法

静态变量和成员变量的区别

1.静态变量又叫类变量，成员变量又叫对象变量
2.所属不同：
    静态变量属于类（）
    成员变量属于对象，所以也称之为实例变量（对象变量）
3.内存中的位置不同
    静态变量属于类，在方法区的静态区
    成员变量存储与堆内存
4.内存出现时间不同
    静态变量随着类的加载而加载，随着类的消失而消失
    成员变量随着对象的创建而存在，随着对象的消失而消失
5.调用不同
    静态变量可以通过类名调用，也可以通过对象调用
    成员变量只能通过对象调用

---

代码块的概述：使用{}括起来的代码就称之为代码块

代码块的分类：

根据其位置和声明的不同，可以分为：

• 局部代码块
• 构造代码块
• 静态代码块
• 同步代码块（多线程）

局部代码块：在方法中出现，限定变量的生命周期，及早释放，提高内存的利用率

构造代码块：在类中方法外出现，多个构造方法中相同代码存放到一起，每次调用构造都执行，并且在构造方法前执行（注意了，构造代码块和构造方法可不是同一种东西）

静态代码块（最常用）：在类中方法外出现，并且要加上static修饰，用于给类进行初始化，在加载的时候就执行，并且只执行一次，一般用于加载驱动

//局部代码块
public class null01 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        {
            int a = 1;
            System.out.println(a);
        }//代码块执行结束，变量a被释放
    }

}

//构造代码块
class Student{
    String name;
    int age;
    public Student(){
        name = "null";
        age = 20;
    }
    {
        System.out.println("这就是构造代码块");
    }
}
//每次都会执行，而且是优先于构造方法执行的

//静态代码块
class Student{
    String name;
    int age;
    public Student(){
        name = "null";
        age = 20;
    }
    {
        System.out.println("这就是构造代码块");
    }
    static{
        System.out.println("这里是静态代码块");
    }//在加载的时候就会执行，而且只会执行这一次。一般用于加载驱动
}

继承概述：让类与类之间产生关系，子父关系

继承的好处：

• 提高代码的复用性
• 提高代码的维护性
• 让类与类之间产生了关系，继承是多态的前提

继承的弊端：

• 类的耦合性增强了
• 开发的原则：高内聚（自己完成某事），低耦合

继承的特点：

• Java只支持单继承，不支持多继承（关键字 extends）
• Java支持多层继承
  • 如果想用这个体系的所有功能，我们有最底层的类来创建对象
  • 如果想用这个体系的共性功能，我们调用最顶层的类

继承的注意事项：

• 子类只能继承父类所有的非私有的成员（非私有的成语方法和成员变量）
• 子类可以通过super关键字访问父类的东西

super和this

• super的作用：super指的是当前类的对象的父类引用
• super可以调用父类的成员属性  super.成员变量
• super可以调用父类的成员方法  super.成员方法
• super可以调用父类的构造方法  super(...)
• .
• this的作用：this指的是当前类的对象引用
• this可以调用本类的成员属性
• this可以调用本类的成员方法
• this可以调用父类的成员方法（在本类没有的情况下）  this.父类方法、this.父类属性
• this可以调用本类的构造方法

继承中的构造方法的关系

子类中的所有的构造方法默认都会访问父类中空参数的构造方法

　　应为子类会继承父类中的数据，可能还会使用父类的数据，所以在子类的初始化之前，一定要用super首先要完成父类的初始化

　　所以我们会发现，当我们利用Eclipse工具生成子类的构造方法时就会存在super()方法

继承工构造方法的注意事项

• 子类必须创建无参构造方法，内还要调用父类的构造方法
• 子类实现有参构造方法
• 父类自己实现无参构造方法
• super（）和this都是必须出现在构造方法的第一条语句上

方法的重写

指的是子类中出现和父类一模一样的方法。重写这个概念只存在与继承的父子之间

应用场景：

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

注意事项：

　　父类中私有方法不能重写，因为父类私有方法子类根本就无法继承

　　子类重写父类的时候，访问权限最好一致

方法的重写与重载

Overload是指方法的重载，重载可以改变返回值类型，方法的重载只看参数类表不同

Override是指方法的重写，也就是子类中出现了和父类中方法声明一模一样的方法

方法的重写与返回值类型有关，返回值是一致的（或者是子父类）的

方法的重载，在本类中出现的方法名相同，参数列表不同。与返回值类型无关

Final关键字修饰类，方法以及变量

final修饰的特点：

• 修饰类，类不能被继承
• 修饰变量，变量就变成了常量，只能被赋值一次
• 修饰方法，方法就不能被重写

修饰变量：

• final修饰变量叫常量，一般会与public static公用
• 注：常量的变量名一定要全部大写

final修饰局部变量：

• 修饰基本类型，值不能被改变
• 修饰引用类型，是地址不能被改变，对象中的属性可以改变
• 修饰引用类型，那就不可以在new对象了

多态的概述 

什么是多态：事物的多种状态...

Java中存在多态的前提条件：

• 要有继承关系
• 要有方法的重写
• 要有父类引用指向子类对象（Father son = new Son()）

多态中的成员访问特点：

• 成员变量：编译看左边（父类），运行看左边（父类）
• 成员方法：编译看左边（父类），运行看右边（子类）
• 静态方法：编译看左边（父类），运行看左边（父类）
• 总结：只有非静态的成员方法，编译看左边，运行看右边

注意：在多态的写法中，父类指向了子类，我们实例化然后调用一个方法是，这个方法在父类中必须存在，否则将会无法进行编译

多态中的向上转型和向下转型

• 向上转型：父类指向子类对象 Father p = new Son（）；
• 向下转型：子类指向父类对象 Son son = （Son）p；

　　向下转型注意：父类的真实对象必须是子类对象，否则会有问题

多态的好处与弊端：

• 提高了代码的维护性
• 提高了代码的扩展性
• 但是却不能使用子类的特有属性和行为

抽象类的特点：

• 抽象类和抽象方法必须用abstract关键字修饰
  • abstract class 类名{}
  • public abstract void eat（）；
• 抽象类不一定有抽象方法，有抽象方法的类一定是个抽象类或者是接口
• 抽象类不能实例化，要由具体的子类实例化。这也是多态的一种（抽象类多态）
• 抽象类的子类：要么是抽象类，要么重写抽象类中所有的抽象方法

抽象类的成员的特点：

• 成员变量：既可以是变量，也可以是常量。
• abstract不能修饰成员变量，只能修饰类和方法
• 构造方法：抽象类也是有构造方法的，用于子类访问父类数据的初始化
• 成员方法：抽象类的方法可以是抽象的，也可以是非抽象的

抽象类的成员的特性：

• 抽象方法：强制要求子类实现
• 非抽象方法：子类可以继承实现

接口

• 从狭义的角度上将，就是指java中的interface关键字
• 从广义上讲对外提供规则的都是接口
• 接口就是提供对外访问的规则

接口的特点：

• 接口用关键字interface表示   interface 接口名{}
• 类去实现接口用implements表示  class 类名  implements  接口名{}
• 接口不能进行实例化
• 接口的子类可以是抽象类（没有意义），一个具体的类，要重写接口中的所有方法

类与类，类与接口，接口与接口的关系

类与类：

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

类与接口：

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

接口与接口：

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

抽象类与接口的区别

1.成员区别

• 抽象类可以有成员变量，也可以有常量，构造方法，成员方法（抽象的和非抽象的）
• 接口只能有变量，方法只能是抽象方法

2.关系区别

• 类与类：继承关系，单继承
• 类与接口：实现关系，单实现和多实现均可
• 接口与接口：继承关系，单继承与多继承

3.设计理念的区别

• 抽象类：抽象类中定义的是该继承体系的共性功能
• 接口：接口中定义的是该继承体系的扩展功能

package关键字的概述以及作用

package包的作用：

• 包其实就是文件夹
• 包的作用是将字节码（.class）进行分类存放
• 包的作用可以使在同一个项目中有相同的类
• 包的作用有利于以后功能模块的划分

包的格式的定义：

• 包名一般使用公司域名的倒写

包的类能被其他的包访问，那么这个包一定是public的类，public修饰的类代表其他包可以访问此类

四中权限修饰符：
　　private，default，protected，public

　　所谓的权限就是别人是否能访问类、属性、方法

用在类上的修饰符：default，public，final（状态修饰符），abstract（抽象修饰符）

用在成员上的修饰符：权限修饰符（private，default，protected，public），状态修饰符（static，final）

用在构造方法上的修饰符：权限修饰符（private，default，protected，public）

用在成员方法上的修饰符：权限修饰符（private，default，protected，public），状态修饰符（static，final），抽象修饰符（abstract）

protected关键字

表示受保护的

protected修饰的方法只能在当前包中访问，或者由子类访问

 内部类

内部类的概述和访问特点

• 内部类的概述：就是在class类的内部再定义一个class类
• 内部类的访问特点：
  • 内部类可以直接访问外部类的成员，包括私有的
  • 外部类要访问内部类的成员，必须要去创建对象

内部类的创建语法：

　　外部类名.内部类名 对象名 = 外部类对象.内部类对象；

　　注：开发中自己声明的内部类比较少用，用的较多的是集合中的遍历

public class null01内部类 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //创建内部类的对象
        Outer.Inner inner = new Outer().new Inner();
        inner.test1();
    }

    //在一个类的内部声明类，所以他是一个内部类
//    class Student{
        
//    }
    
}
//此时声明类在另一个类的外面，所以这是一个外部类
//class Student{
    
//}
//这是一个外部类
class Outer{
    int a = 12;
    private int b = 13;
    //这是一个内部类
    class Inner{
        public void test1(){
            System.out.println("内部访问外部的一个变量a:"+a);
            System.out.println("内部访问外部的私有属性b:"+b);
            
        }
    }
}

1.私有内部类的使用

注：private修饰的，只能在内部访问，所以就无法使用外部类名.内部类名了

那我们如何使用？

和我们对私有属性的操作类似，在class类的内部声明一个获取方法

public class null02私有内部类 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //权限修饰符：private default protected public
        //类的成员：属性，方法，内部类
        
        //创建内部类对象
        //注：private只能在内部访问，所以无法使用Outer.Inner
        //私有的内部类，就不能在外部调用了
        Insert outer = new Insert();
        outer.test();
    }

}
class Insert{
    int a = 12;
    private int b = 13;
    //这是一个内部类
    private class Inner{
        public void test1(){
            System.out.println("内部访问外部的一个变量a:"+a);
            System.out.println("内部访问外部的私有属性b:"+b);
            
        } 
    }
    public void test(){
        Inner inner = new Inner();
        inner.test1();
    }
}

2.静态内部类的使用

创建静态内部方法对象的语句：

　　注意：说道对象，那就是new出来的东西了，这个才叫对象

　　外部类名.内部类名 对象名 = 外部类名.内部类对象;

public class null03静态内部类 {
    public static void main(String[] args){
        
        //创建静态内部方法对象语法：外部类名.内部类名  对象名 = 外部类名.内部类对象;
        OuterThree.Inner inner = new OuterThree.Inner();
        inner.test1();
        
        
    }
}
class OuterThree{
    static int a = 12;
    static int b = 13;
    //这是一个内部类
    static class Inner{
        public void test1(){
            System.out.println("内部访问外部的一个变量a:"+a);
            System.out.println("内部访问外部的私有属性b:"+b);
            
        } 
    }
}

3.调用静态内部类的静态方法

静态内部类的静态方法调用：

　　外部类.静态内部类,静态内部方法；

public class null04调用静态类的静态方法 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        
        //调用静态内部类的静态方法
        OuterFour.Inner.test1();
    }

}

class OuterFour{
    static int  a = 1;
    
    //静态的内部类
    static class Inner{
        public static void test1(){
            System.out.println("这里是静态类的静态方法");
            
        }
    }
    
}

4.局部内部类

• 局部内部类如果想要访问局部变量，那么局部变量必须用final修饰
  • 如果不用final修饰，在某些情况下，可能变量会先弹出，但是局部内部类还在存活
• 局部内部类访问它所在的方法中的局部变量必须用final修饰
• 注意：jdk1.8以上的版本不需要加final代码也不会报错了

public class Demo01 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test1();
    }
}

class Outer{
    public void test1(){
        final int a = 10;//局部变量
        class Inner{//局部内部类
            public void test2(){
                System.out.println(a);
            }
        }
        Inner inner = new Inner();
        inner.test2();
    }
}

5.匿名内部类

• 抽象的或者接口的匿名内部类
  • 匿名内部类就是内部类的简化方法
  • 写匿名内部类的前提是存在一个抽象内部类或者是接口
  • 匿名内部类的实现格式：  new 抽象或者是接口名（）{重写方法};
  • 匿名内部类的本质：是一个继承了该类或者实现了该接口的子类的匿名对象
  • 匿名内部类的特点：匿名内部类必须实现接口的所有方法；匿名内部类必须实现抽象类的所有方法
  • 匿名内部类的方法调用：就像是普通的对象一样，调用方法即可

public class null05匿名内部类 {
    public static void main(String[] args){
    
        //不能直接调用抽象类
        //可以通过子类去重写抽象类
        Dog dog = new Dog();
        dog.eat();
        //可以通过匿名内部类，其实也是匿名方法
        new Animal(){
            @Override
            public void eat(){
                System.out.println("这个是匿名内部方法");
            }
        }.eat();
        
    }
    
    
}

//写一个抽象类
abstract class Animal{
    public abstract void eat();
}
class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("我是.....");
    }
}

public class null06接口的匿名内部类 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //第一中class实现接口的调用
        DogSix dog = new DogSix();
        dog.jumpFileCircle();
    
        new AnimalSix(){
            @Override
            public void jumpFileCircle() {
                // TODO Auto-generated method stub
                System.out.println("annother Jump....");
            }
        }.jumpFileCircle();
        AnimalSix annther = new AnimalSix(){
            @Override
            public void jumpFileCircle(){
                System.out.println("three jump....");
            }
        };
        annther.jumpFileCircle();
    
    
    }

}

interface AnimalSix{
    //跳火圈
    public void jumpFileCircle();
}
//之前说接口不能直接new，
//如何使用接口、
//1.写一个类，实现接口
class DogSix implements AnimalSix{
    @Override
    public void jumpFileCircle(){
        System.out.println("jump...");
    }
}
//2.new一个接口的匿名

补充一道面试题：

package nullnull;

interface Inter
{
    void show();
}
class Outer{
    //补齐代码
}
class OutDemo{
    public static void main(String[] args){
        Outer.method().show();
    }
}
//在控制台输出“Helloworld”

interface Inter
{
    void show();
}
class Outer{
    //补齐代码
    public static Inter method(){
        return  new Inter(){
            @Override
            public void show(){
                System.out.println("Helloworld");
            }
        };
    }
}
class OutDemo{
    public static void main(String[] args){
        Outer.method().show();
    }
}