深入面向对象（二）

1、大纲

在这里插入图片描述

2、package与import

package
package存在的意义是防止命名冲突造成使用不便。
一般的命名为：公司域名倒写+功能名|模块名。
import
如果一个类存在包名，则在其他包下使用该类时，必须使用全额限定名（简称全名或完整类名，
com.java01.MyClass），编译器才能找到该类；也可以使用 import 在文件的开头引入要使用到的类。
不需要使用 import 的类有:

语言包（java.lang）下的类 (String,System…)
同包下的类
静态导入： import 语句不仅可以导入类，还增加了导入静态方法的功能

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

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….

3、垃圾回收机制（gs）

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

4、block与debug

（i）block
块{},在java中自成作用域，可以分为
在这里插入图片描述
注意:
类第一次被载入时先执行static代码块；类多次载入时，static代码块只执行一次；static块经常用来进行static变量的初始化。
是在类初始化时执行，不是在创建对象时执行。
静态初始化块中不能访问非static成员。
构造块被被编译到将要执行的构造器代码之前执行静态块，仅在类的第一次使用时加载。构造块，先于构造器执行，每创建一个对象执行一次
（ii）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命令终止对本地程序的调试。

5、面向对象-继承类

继承的作用 :
使用继承可以提高代码的复用性。
如何使用继承:
父类|超类|基类:根据一些列子类抽象,抽取像的部分,定义在父类中
子类|派生类:子类继承父类,有权使用父类中的内容,可以定义子类新增内容,所以说子类是父类的延续+扩展
extends 关键字的意思是“扩展”。子类是父类的扩展。
java 中使用 extends 关键字实现类的继承机制，语法规则：

class [extends ]{}

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

注意
（i）子类继承父类的成员变量和成员方法，但不继承父类的构造方法
（ii）java中只有单继承，没有像c++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
（iii）java中的多继承，可以通过接口来实现
（iv）如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object
继承的特点
优点:
(I)通过继承可以简化类的定义，实现代码的重用|提高代码复用性
(II)可以更好的扩展程序
(III)子类一旦继承父类,可以有权使用父类中的成员,也可以扩展定义子类独有内容
(IV)java是单继承继承,实现简单
缺点:
（I）子类与父类之间紧密耦合(耦合度高)，子类依赖于父类的实现，子类缺乏独立性。
(II)不便于后期维护
(III)单继承一个子类只能有一个父类,不够灵活,不便于后期维护

6、super关键字

super是指向父类的引用。
super可以在子类构造器中调用父类某个构造器
super可以用来区分子父类中同名成员
在这里插入图片描述
构造方法调用顺序：
根据super的说明，构造方法第一句总是：super(…)来调用父类对应的构造方法。
先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。

this与super的区别

相同点:

扫描二维码关注公众号，回复： 11086484 查看本文章

this和super都能用来调动其他共构造器,都要在首行出现
this和super都可以用来区分同名问题,不区分同名时候可以省略
this和super都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句
块。
不同点:
this(参数)构造器第一行调用本类中其他构造器,super(参数)构造器第一行调用父类中某个构造器
this用来区分成员和局部同名问题,super用来区分子父类中同名问题
this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然
也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会
过。
从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字

7、重写与final关键字

重写Override
父类的功能实现不满足子类的要求，可以在子类中按需改写,这就是方法的重写。
实现重写的三个条件:
不同的两个类
继承关系|实现关系
方法签名相同
*@Override:*注解,强制检查是否为重写方法

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("我认识的人都没我有钱"); } }

重写的三个"=" : “==”：方法名、形参列表相同。
“≤”：抛出的异常类型与返回值类型,返回值类型如果为基本类型必须相同，引用数据类型子类小于等于父类。 “≥”：访问权限，子类大于等于父类。

以下修饰符、修饰的内容不能重写:
1. private修饰的方法不能被重写
2. final修饰的方法不能被重写
3. static修饰的方法不能被重写(子类如果出现和父类静态方法同名情况,那么子类中的方法也必须为静态的)

final 表示最终的。
final可以用来修饰变量，方法，类。
修饰变量：变量一旦被初始化便不可改变，相当定义了一常量。

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

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

final void eat() { … }

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

final class Person{ … }

8、Object类

Object 类是所有 Java 类的根基类如果在类的声明中未使用 extends 关键字指明其基类，则默认基类为 Object 类

toString():
当打印对象的引用时,默认调用toString()方法
默认返回:包名+类名+@+哈希码(根据对象的内存地址生成,唯一不重复)
可以重写,实现义字符串的形式返回对对象(打印对象所有成员属性的值

User p1=new User("张三",20); 
System.out.println(p1); 
//相当于 
System.out.println(p1.toString());

equals:比较相等是否相等
默认地址比较(”第一个盒子的比较”)
重写可以是实现比较两对象的内容是否一致

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

注意:自定义类须重写equals()，否则无法实现比较其内容

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

java快到碗里来

发布了22 篇原创文章 · 获赞 6 · 访问量 457

私信关注