java面向对象深刻

时间 2020-06-02

标签 java 面向对象深刻栏目 Java 繁體版

原文原文链接

java面向对象深刻

大纲java

package与import

package

概述c++

package存在的意义是防止命名冲突形成使用不便。程序员

package相似一个文件夹，文件夹内有各类文件。package与package的附属关系用“.”链接，相似父文件夹中的子文件夹。好比说 java.lang.String就是java文件夹中的lang文件夹中的String文件。java.io.InputStream则是java文件夹中的io文件夹中的InputStream文件。算法

同一个文件夹内没法存在同名的文件，而不一样名的文件夹里容许存在同名文件，所以不一样文件夹（即不一样package中容许出现相同class名）。sql

为了便于管理大型软件系统中数目众多的类，解决类的命名冲突问题，Java 引入包(package)机制，提供类的多重类命名空间。 数据库

格式编程

通常的命名为：公司域名倒写+功能名|模块名。网络

package 语句做为 Java 源文件的第一条语句，指明该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）。并发

<span > <span >package</span> <span >pkg1</span>[.<span >pkg2</span>[.<span >pkg3…</span>]];</span>

例：jvm

<span > <span >package</span> <span >com</span>.<span >java01</span>.<span >test</span>;</span>

Java 编译器把包对应于文件系统的目录管理，package 语句中，用’.’来指明包（目录）的层次，例如使用语句: package com.java01 ,则该文件中全部的类位于.\com\java01 目录下

注意:

不要定义与 jdk 相同的包，相同的类，不然会引发不少你以为莫名其妙的问题
写项目时都要加包，不要使用默认包。
com.oop和com.oop.test，这两个包没有包含关系，是两个彻底独立的包。只是逻辑上看起来后者是前者的一部分。

import

若是一个类存在包名，则在其余包下使用该类时，必须使用全额限定名（简称全名或完整类名，com.java01.MyClass），编译器才能找到该类；也可使用 import 在文件的开头引入要使用到的类。

<span > <span >import</span> <span >java</span>.<span >util</span>.<span >Scanner</span>;
 <span >import</span> <span >java</span>.<span >io</span>.<span >*</span>; <span >//模糊匹配当前io包下全部类</span>
 <span >public</span> <span >class</span> <span >ImportDemo</span> {
     <span >public</span> <span >static</span> <span >void</span> <span >main</span>(<span >String</span>[] <span >args</span>) {
         <span >Scanner</span> <span >sc</span><span >=</span><span >new</span> <span >Scanner</span>(<span >System</span>.<span >in</span>); <span >//由于使用import关键字导包,可使用</span>
         <span >java</span>.<span >util</span>.<span >ArrayList</span> <span >list</span><span >=</span><span >new</span> <span >java</span>.<span >util</span>.<span >ArrayList</span>(); <span >//权限定名</span>
         <span >//导入集合 注意:导入是不要导错包</span>
         <span >//使用*,模糊匹配</span>
         <span >File</span> <span >file</span><span >=</span><span >new</span> <span >File</span>(<span >"D://test.txt"</span>);
         <span >InputStream</span> <span >isInputStream</span><span >=</span><span >new</span> <span >FileInputStream</span>(<span >file</span>);
     }
 }</span>

不须要使用 import 的类有:

语言包（java.lang）下的类 (String,System...)
同包下的类

静态导入： import 语句不只能够导入类，还增长了导入静态方法的功能

<span > <span >//导入静态属性</span>
 <span >import</span> <span >static</span> <span >java</span>.<span >lang</span>.<span >Math</span>.<span >PI</span>;
 <span >import</span> <span >static</span> <span >java</span>.<span >lang</span>.<span >System</span>.<span >out</span>;
 <span >//导入静态方法</span>
 <span >import</span> <span >static</span> <span >java</span>.<span >lang</span>.<span >Math</span>.<span >sin</span>;
 
 <span >public</span> <span >class</span> <span >ImportDemo</span> {
     <span >public</span> <span >static</span> <span >void</span> <span >main</span>(<span >String</span>[] <span >args</span>) {
         <span >out</span>.<span >println</span>(<span >PI</span>);
         <span >sin</span>(<span >1.1</span>);
     }
 }</span>

总结

若是想将一个类放入包中，在类的源文件首行使用package
必须保证该类的 class 文件位于正确的目录下
另外的类想访问的话：
1. 写全名
2. 引入
  - 模糊匹配（会将该包下全部用到的类引入进来），会下降编译速度，可是不会影响运行速度
  - 具体类名
  - 静态导入
3. 同包下的类不须要导入

JDK 中经常使用的包简单介绍：

java.lang –语言包：语言中经常使用的功能，如：String、Math、System、Integer、Thread…
java.util – 工具包：提供一些实用的工具类，如：容器（List、Set、Map…）,日期类
java.io – 输入输出包：提供操做读取文件的相关类，如：File、InputStream、OutputStream…
java.net – 网络包：操做远程资源的类，如：InetSocketAddress、 DatagramPacket、 ServerSocket…
java.sql – 数据库包：操做JDBC的类，Connection、Statement、ResultSet….

垃圾回收机制（gc）

概述

Garbage Collection 垃圾回收机制

每一个程序员都遇到过内存溢出的状况，程序运行时，内存空间是有限的，那么如何及时的把再也不使用的对象清除将内存释放出来，这就是GC要作的事。

提及垃圾回收机制（GC），大部分人都把这项技术当作Java语言的伴生产物。事实上，GC的历史比Java久远，早在1960年Lisp这门语言中就使用了内存动态分配和垃圾回收技术。

程序员们知道，jvm内存结构分为五大区域：程序计数器、虚拟机栈、本地方法栈、堆区、方法区。其中虚拟机栈、本地方法栈与程序计数器这3个区域随线程而生、随线程而灭，所以就不须要考虑过多内存垃圾回收问题，由于一个方法调用结束或者线程结束时，内存天然就跟随着回收了。

咱们就把重点放在方法区与堆区，这部份内存的分配和回收是动态的，正是垃圾收集器所需关注的部分。

GC主要作了清理对象，整理内存的工做。

不一样语言下对象空间的释放：

传统的C/C++语言，须要程序员负责回收已经分配内存。显式回收垃圾回收的缺点：
1. 程序忘记及时回收，从而致使内存泄露，下降系统性能。
2. 程序错误回收程序核心类库的内存，致使系统崩溃。
Java语言不须要程序员直接控制内存回收，是由JRE在后台自动回收再也不使用的内存，称为垃圾

回收机制(Garbage Collection)。
1. 能够提升编程效率。
2. 保护程序的完整性。
3. 其开销影响性能。Java虚拟机必须跟踪程序中有用的对象，肯定哪些是无用的。

垃圾回收机制关键点:

垃圾回收机制只回收JVM堆内存里的对象空间。
对其余物理链接，好比数据库链接、输入流输出流、Socket链接无能为力
如今的JVM有多种垃圾回收实现算法，表现各异。
垃圾回收发生具备不可预知性，程序没法精确控制垃圾回收机制执行。
能够将对象的引用变量设置为null，暗示垃圾回收机制能够回收该对象。
程序员能够经过System.gc()或者Runtime.getRuntime().gc()来通知系统进行垃圾回收，会有一些效果，可是系统是否进行垃圾回收依然不肯定。
垃圾回收机制回收任何对象以前，总会先调用它的finalize方法（若是覆盖该方法，让一个新的引用变量从新引用该对象，则会从新激活对象）。
永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

block与debug

block

块{},在java中自成做用域，能够分为

静态代码块

构造代码块

普通语句块

同步代码块

声明位置

类中,方法外

方法中

fynchronized(){}

做用

整个类进行某些初始化操做(静态属性赋值...)

构造代码块是为对象初始化操做(为静态或非静态成员属性赋值...)

声明一些临时变量等..

控制并发

执行时机

类第一次加载时,只执行一次,若是多个静态块,从上倒下一次执行

建立对象时,执行构造器代码以前执行,若有多个,从上倒下一次执行

跟随方法执行

跟对方法执行

注意:

类第一次被载入时先执行static代码块；类屡次载入时，static代码块只执行一次；static块常常用来进行static变量的初始化。
是在类初始化时执行，不是在建立对象时执行。
静态初始化块中不能访问非static成员。
构造块被被编译到将要执行的构造器代码以前执行

静态块，仅在类的第一次使用时加载。构造块，先于构造器执行，每建立一个对象执行一次

debug

在学习或开发过程当中,遇到bug是避免不了的,为了可以快速调试,可使用debug调试工具。

调试一个Java程序很是简单的，主要有设置断点、启动调试、单步执行、结束调试几步。

debug界面窗口:

1)设置断点

2)启动调试

Eclipse提供几种方式来启动程序(Launch)的调试，分别是经过菜单(Run –> Debug)、图标(“绿色臭虫”)、右键->Debug As。

弹出提示，须要切换到调试（Debug）工做区，勾选“Remember my decision”，记住选择，则下次再也不提示，而后点击【Yes】。

3)单步执行

主要使用前面讲过的几个视图进行调试，其中debug视图中的几个按钮有快捷键:

Step Return(F7) : 表示退出当前方法，返回到调用层。

Step Over (F6) : 表示运行下一行代码。

Step Into (F5) : 表示进入当前方法。

4)结束调试

经过Terminate命令终止对本地程序的调试。

面向对象-继承性

继承

“树上一只鸟树下两只兔子，请问几种动物 , 请问几种生物?” 这里面就存在了继承的概念。

继承：子承父业

继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。

继承的做用 : 使用继承能够提升代码的复用性。

如何使用继承:

父类|超类|基类:根据一些列子类抽象,抽取像的部分,定义在父类中

子类|派生类:子类继承父类,有权使用父类中的内容,能够定义子类新增内容,因此说子类是父类的延续+扩展

extends 关键字的意思是“扩展”。子类是父类的扩展。

java 中使用 extends 关键字实现类的继承机制，语法规则：

<span > <span ><</span><span >modifier</span><span >></span> <span >class</span> <span ><</span><span >name</span><span >></span> [<span >extends</span> <span ><</span><span >superclass</span><span >></span>]{} </span>

<span > <span >//父类</span>
 <span >class</span> <span >Person</span>{
     <span >public</span> <span >String</span> <span >name</span>;
     <span >public</span> <span >int</span> <span >age</span>;
     
     <span >public</span> <span >void</span> <span >sleep</span>(){
         <span >System</span>.<span >out</span>.<span >println</span>(<span >"休息"</span>);
     }
 }</span>

<span > <span >//子类</span>
 <span >//教师类</span>
 <span >class</span> <span >Teacher</span> <span >extends</span> <span >Person</span>{
     <span >public</span> <span >String</span> <span >subject</span>;
     
     <span >public</span> <span >Teacher</span>() {
     }
     
     <span >public</span> <span >void</span> <span >teach</span>(){
         <span >System</span>.<span >out</span>.<span >println</span>(<span >"传授知识"</span>);
     }
     
 }
 
 <span >//学生类</span>
 <span >class</span> <span >Student</span> <span >extends</span> <span >Person</span>{
     <span >public</span> <span >String</span> <span >school</span>;
     
     <span >public</span> <span >Student</span>() {
     }
     
     <span >public</span> <span >void</span> <span >study</span>(){
         <span >System</span>.<span >out</span>.<span >println</span>(<span >"在知识的海洋畅游!"</span>);
     }
 }</span>

注意:

子类继承父类的成员变量和成员方法，但不继承父类的构造方法
java中只有单继承，没有像c++那样的多继承。多继承会引发混乱，使得继承链过于复杂，系统难于维护。就像咱们现实中，若是你有多个父母亲，那是一个多么混乱的世界啊。多继承，就是为了实现代码的复用性，却引入了复杂性，使得系统类之间的关系混乱。
java中的多继承，能够经过接口来实现
若是定义一个类时，没有调用extends，则它的父类是：java.lang.Object。

继承的特色:

优势:

经过继承能够简化类的定义，实现代码的重用|提升代码复用性
能够更好的扩展程序
子类一旦继承父类,能够有权使用父类中的成员,也能够扩展定义子类独有内容
java是单继承继承,实现简单

缺点:

子类与父类之间紧密耦合(耦合度高)，子类依赖于父类的实现，子类缺少独立性。
不便于后期维护
单继承一个子类只能有一个父类,不够灵活,不便于后期维护

super关键字

super

super是指向父类的引用。

super能够在子类构造器中调用父类某个构造器

若是构造方法没有显示地调用父类的构造方法，那么编译器会自动为它加上一个默认的super()方法调用。若是父类由没有默认的无参构造方法，编译器就会报错，super()语句必须是构造方法的第一个子句。

super能够用来区分子父类中同名成员

若是不存在同名问题,能够直接在子类中调用父类内容,super默认省略

若是存在同名问题,在子类中调用同名成员,默认this.恒源调用当前子类同名成员,先要调用父类同名成员,必须定义为super.成员

<span > <span >//父类</span>
 <span >public</span> <span >class</span> <span >Animal</span> {
     <span >int</span> <span >eye</span> <span >=</span> <span >2</span>;
     <span >public</span> <span >Animal</span>(){
         <span >super</span>();
         <span >System</span>.<span >out</span>.<span >println</span>(<span >"动物"</span>);
     }
     
     <span >public</span> <span >void</span> <span >run</span>(){
         <span >System</span>.<span >out</span>.<span >println</span>(<span >"动物有不一样走路方式"</span>);
     }
     
     <span >public</span> <span >static</span> <span >void</span> <span >main</span>(<span >String</span>[] <span >args</span>) {
         <span >Bird</span> <span >b</span> <span >=</span> <span >new</span> <span >Bird</span>();
         <span >b</span>.<span >run</span>();
     }
 }
 <span >//子类</span>
 <span >class</span> <span >Bird</span> <span >extends</span> <span >Animal</span>{
     <span >public</span> <span >Bird</span>(){
         <span >super</span>();
         <span >System</span>.<span >out</span>.<span >println</span>(<span >"鸟类"</span>);
     }
 
     <span >public</span> <span >void</span> <span >run</span>() {
         <span >super</span>.<span >run</span>(); <span >// 经过super能够用父类方法和属性</span>
         <span >System</span>.<span >out</span>.<span >println</span>(<span >"鸟是飞飞飞飞飞飞"</span>);
         <span >System</span>.<span >out</span>.<span >println</span>(<span >"鸟类有"</span><span >+</span><span >super</span>.<span >eye</span><span >+</span><span >"只眼睛"</span>);
     }
    
 }</span>

Bird--> Animal --> Object 图形分析以下

构造方法调用顺序：

根据super的说明，构造方法第一句老是：super(…)来调用父类对应的构造方法。
先向上追溯到Object，而后再依次向下执行类的初始化块和构造方法，直到当前子类为止。

this和super之间的区别

相同点:

this和super都能用来调动其余共构造器,都要在首行出现
this和super均可以用来区分同名问题,不区分同名时候能够省略
this和super都指的是对象，因此，均不能够在static环境中使用。包括：static变量,static方法，static语句

块。

不一样点:

this(参数)构造器第一行调用本类中其余构造器,super(参数)构造器第一行调用父类中某个构造器
this用来区分红员和局部同名问题,super用来区分子父类中同名问题

注意:

this和super不能同时出如今一个构造函数里面，由于this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，因此在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会过。
从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字

重写与final关键字

重写Override

父类的功能实现不知足子类的要求，能够在子类中按需改写,这就是方法的重写。

实现重写的三个条件:

不一样的两个类
继承关系|实现关系
方法签名相同

@Override:注解,强制检查是否为重写方法

注意：

子类重写的方法会对父类的方法进行屏蔽。
当子类对象调用时,会调用子类中重写的方法,子类没有找父类。

<span >public class OverrideTest {
    public static void main(String[] args) {
        Sicong sicong=new Sicong();
        sicong.getMoney(); //调用子类中重写方法
    }
}
//父类
class Jianlin{
    public void getMoney(){
        System.out.println("先定一个小目标,赚他个一个亿");
    }
}
//子类
class Sicong extends Jianlin{
    @Override  //强制检查是否为重写方法
    public void getMoney(){
        super.getMoney();//在父类的原赚钱方法上扩展新功能,老功能不变
        System.out.println("我认识的人都没我有钱");
    }
}
</span>

重写的三个"=" : “==”：方法名、形参列表相同。

“≤”：抛出的异常类型与返回值类型,返回值类型若是为基本类型必须相同，引用数据类型子类小于等于父类。

“≥”：访问权限，子类大于等于父类。

如下修饰符、修饰的内容不能重写:

private修饰的方法不能被重写
final修饰的方法不能被重写
static修饰的方法不能被重写(子类若是出现和父类静态方法同名状况,那么子类中的方法也必须为静态的)

final关键字

final 表示最终的。

final能够用来修饰变量，方法，类。

修饰变量：变量一旦被初始化便不可改变，至关定义了一常量。

<span >final int x=3;
//x=4; 常量不能改变
</span>

修饰方法 : final方法是在子类中不能被覆盖的方法

<span >final void eat() { … }
</span>

修饰类，表示该类不能被继承

<span >final class Person{ … }
</span>

Object类

Object 类是全部 Java 类的根基类

若是在类的声明中未使用 extends 关键字指明其基类，则默认基类为 Object 类

toString(): 当打印对象的引用时,默认调用toString()方法

默认返回:包名+类名+@+哈希码(根据对象的内存地址生成,惟一不重复)
能够重写,实现义字符串的形式返回对对象(打印对象全部成员属性的值)

<span >User p1=new User("张三",20);
System.out.println(p1);
//至关于
System.out.println(p1.toString());
</span>

equals:比较相等是否相等**

默认地址比较(”第一个盒子的比较”)
重写能够是实现比较两对象的内容是否一致

<span > object1.equals(object2) 
 如 : p1.equals(p2)
• 比较所指对象的内容是否同样,具体看equals的方法重写
 object1 == object2
 如：p1==p2
• 比较p1和p2的值即内存地址是否相等，便是否是指向同一对象。
</span>

注意:自定义类须重写equals()，不然没法实现比较其内容

<span >class User{
    String name;
    int age;
    public User() {
        // TODO Auto-generated constructor stub
    }
    public User(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    //重写toString
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + "]";
    }
    //重写equals
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}
</span>