标签：执行 规则 his res 初始化 垃圾回收机制 private 收集 知识
java面向对象深入package存在的意义是防止命名冲突造成使用不便。
package类似一个文件夹，文件夹内有各种文件。package与package的附属关系用“.”连接，类似父文件夹中的子文件夹。比如说 java.lang.String就是java文件夹中的lang文件夹中的String文件。java.io.InputStream则是java文件夹中的io文件夹中的InputStream文件。
同一个文件夹内无法存在同名的文件，而不同名的文件夹里允许存在同名文件，因此不同文件夹（即不同package中允许出现相同class名）。
<font color=‘red‘>为了便于管理大型软件系统中数目众多的类，解决类的命名冲突问题，Java 引入包(package)机制，提供类的多重类命名空间。 </font>
一般的命名为：<font color="blue">公司域名倒写+功能名|模块名。</font>
package 语句作为 Java 源文件的第一条语句，指明该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）。
package pkg1[.pkg2[.pkg3…]];例：
package com.java01.test;Java 编译器把包对应于文件系统的目录管理，package 语句中，用’.’来指明包（目录）的层次，例如使用语句: package com.java01 ,则该文件中所有的类位于.\com\java01 目录下
注意:
如果一个类存在包名，则在其他包下使用该类时，必须使用全额限定名（简称全名或完整类名，com.java01.MyClass），编译器才能找到该类；也可以使用 import 在文件的开头引入要使用到的类。
import java.util.Scanner;
import java.io.*; //模糊匹配当前io包下所有类
public class ImportDemo {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in); //因为使用import关键字导包,可以使用
java.util.ArrayList list=new java.util.ArrayList(); //权限定名
//导入集合 注意:导入是不要导错包
//使用*,模糊匹配
File file=new File("D://test.txt");
InputStream isInputStream=new FileInputStream(file);
}
}不需要使用 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) {
out.println(PI);
sin(1.1);
}
}如果想将一个类放入包中，在类的源文件首行使用package
?
JDK 中常用的包简单介绍：
java.lang –语言包：语言中常用的功能，如：String、Math、System、Integer、Thread…
java.util – 工具包：提供一些实用的工具类，如：容器（List、Set、Map…）,日期类
java.io – 输入输出包：提供操作读取文件的相关类，如：File、InputStream、OutputStream…
java.net – 网络包： 操 作 远 程 资 源 的 类 ， 如：InetSocketAddress、 DatagramPacket、 ServerSocket…
Garbage Collection 垃圾回收机制
每个程序员都遇到过内存溢出的情况，程序运行时，内存空间是有限的，那么如何及时的把不再使用的对象清除将内存释放出来，这就是GC要做的事。
说起垃圾回收机制（GC），大部分人都把这项技术当做Java语言的伴生产物。事实上，GC的历史比Java久远，早在1960年Lisp这门语言中就使用了内存动态分配和垃圾回收技术。
程序员们知道，jvm内存结构分为五大区域：程序计数器、虚拟机栈、本地方法栈、堆区、方法区。其中虚拟机栈、本地方法栈与程序计数器这3个区域随线程而生、随线程而灭，因此就不需要考虑过多内存垃圾回收问题，因为一个方法调用结束或者线程结束时，内存自然就跟随着回收了。
我们就把重点放在方法区与堆区，这部分内存的分配和回收是动态的，正是垃圾收集器所需关注的部分。
GC主要做了清理对象，整理内存的工作。
不同语言下对象空间的释放：
传统的C/C++语言，需要程序员负责回收已经分配内存。显式回收垃圾回收的缺点：
Java语言不需要程序员直接控制内存回收，是由JRE在后台自动回收不再使用的内存，称为垃圾
回收机制(Garbage Collection)。
垃圾回收机制关键点:
块{},在java中自成作用域，可以分为
| 静态代码块 | 构造代码块 | 普通语句块 | 同步代码块 | |
|---|---|---|---|---|
| 声明位置 | 类中,方法外 | 类中,方法外 | 方法中 | fynchronized(){} |
| 作用 | 整个类进行某些初始化操作(静态属性赋值...) | 构造代码块是为对象初始化操作(为静态或非静态成员属性赋值...) | 声明一些临时变量等.. | 控制并发 |
| 执行时机 | 类第一次加载时,只执行一次,如果多个静态块,从上倒下一次执行 | 创建对象时,执行构造器代码之前执行,如有多个,从上倒下一次执行 | 跟随方法执行 | 跟对方法执行 |
注意:
类第一次被载入时先执行static代码块；类多次载入时，static代码块只执行一次；static块经常用来进行static变量的初始化。
是在类初始化时执行，不是在创建对象时执行。
静态初始化块中不能访问非static成员。
构造块被被编译到将要执行的构造器代码之前执行
?
静态块，仅在类的第一次使用时加载。
构造块，先于构造器执行，每创建一个对象执行一次
在学习或开发过程中,遇到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 中使用 <font color="red">extends </font>关键字实现类的继承机制，语法规则：
<modifier> class <name> [extends <superclass>]{} //父类
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("在知识的海洋畅游!");
}
}注意:
优点:
缺点:
super是指向父类的引用。
super可以在子类构造器中调用父类某个构造器
如果构造方法没有显示地调用父类的构造方法，那么编译器会自动为它加上一个默认的super()方法调用。如果父类由没有默认的无参构造方法，编译器就会报错，super()语句必须是构造方法的第一个子句。
super可以用来区分子父类中同名成员
如果不存在同名问题,可以直接在子类中调用父类内容,super默认省略
如果存在同名问题,在子类中调用同名成员,默认this.恒源 调用当前子类同名成员,先要调用父类同名成员,必须定义为super.成员
//父类
public class Animal {
int eye = 2;
public Animal(){
super();
System.out.println("动物");
}
public void run(){
System.out.println("动物有不同走路方式");
}
public static void main(String[] args) {
Bird b = new Bird();
b.run();
}
}
//子类
class Bird extends Animal{
public Bird(){
super();
System.out.println("鸟类");
}
public void run() {
super.run(); // 通过super可以用父类方法和属性
System.out.println("鸟是飞飞飞飞飞飞");
System.out.println("鸟类有"+super.eye+"只眼睛");
}
}Bird--> Animal --> Object 图形分析如下
构造方法调用顺序：
相同点:
块。
不同点:
注意:
this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会过。
父类的功能实现不满足子类的要求，可以在子类中按需改写,这就是方法的重写。
实现重写的三个条件:
继承关系|实现关系
@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("我认识的人都没我有钱");
}
}重写的三个"=" :
“==”：方法名、形参列表相同。
“≤”：抛出的异常类型与返回值类型,返回值类型如果为基本类型必须相同，引用数据类型子类小于等于父类。
“≥”：访问权限，子类大于等于父类。
以下修饰符、修饰的内容不能重写:
final 表示最终的。
final可以用来修饰变量，方法，类。
修饰变量：变量一旦被初始化便不可改变，相当定义了一常量。
final int x=3;
//x=4; 常量不能改变修饰方法 : final方法是在子类中不能被覆盖的方法
final void eat() { … }修饰类，表示该类不能被继承
final class Person{ … }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;
}
}标签：执行 规则 his res 初始化 垃圾回收机制 private 收集 知识
原文地址：https://blog.51cto.com/14816480/2496586
