一、java存储在什么地方
程序运行时，内存是怎么分配，对象存储的位置，这些了解有助于学习java编程。
1、寄存器，最快速的存储区，因为位于处理器内部，但其数量有限，而且不能直接控制，所以java对象不会在这一区域。
2、堆栈，位于RAM中，但通过堆栈指针可以从处理器获得直接支持，java系统必须知道存储在堆栈内所以项的确切生命周期，以便于移动堆栈指针。堆栈指针向上移动，释放内存，向下移动分配内存，其效率仅此于寄存器。（java对象的引用、基本数据类型存储在此区域）
3、堆，位于RAM中，一种通用的内存池，用于存放所以的java对象。当使用new的时候便会在此区域分配需要大小的内存空间。
4、常量存储。常量值通常直接存储于程序代码内部，因为他永远不会被改变。
5、非RAM存储，把数据存储在外部，不受程序控制，程序没有运行也是可以存在。（持久化对象、流对象）
二、基本类型
因为通过new将对象存储在堆中，因为创建简单变量不是非常有效，对于这些简单类型，java不是采用new的方式，而是创建一个并非引用的“自动”变量，这个变量直接存储“值”，并且位于堆栈中，以提高效率。
package com.javabase.study.javaBaseType;
/**
* java 基本数据类(值存储位置为堆栈)，每个基本类型都有对应的包装类型
* 其中boolean和void没有定义大小空间，boolean仅定义可以存储false和true的大小
* 类的基本类型变量创建对象时候会自动初始化默认值，防止错误产生。局部变量则可能得到任何值，不会进行初始化，因此必须初始化在使用。
* BigInteger和BigDecimal为高精度数字，这个两个数字类可以保证数据的准确性，其余以损失精度换取速度
* @author shining
*
*/
public class BaseDataType {
private int i;//0
private boolean b;//false
private char c;//'\u0000'(null)
private byte by;//(byte)0
private long l;//0l
private short s;//(short)0
private float f;//0.0f
private double d;//0.0d
public static void main(String[] args) {
BaseDataType base=new BaseDataType();
System.out.println(base.i);
System.out.println(base.b);
System.out.println(base.c);
System.out.println(base.by);
System.out.println(base.l);
System.out.println(base.s);
System.out.println(base.f);
System.out.println(base.d);
}
}
三、类复用
package com.javabase.study.extend;
/**
* java类复用有两种形式：1、组合(导出类好引用基类)2、继承
* 继承：初始化基类分为两种：1、默认构造器2、有参构造器，此时必须通过super来调用。初始化顺序为基类到导出类。
* @author shining
*
*/
public class JavaExtends extends BoardGame {
JavaExtends(int i) {
super(i);
System.out.println("JavaExtends Constructor");
}
public static void main(String[] args) {
new JavaExtends(0);
}
}
class Game{
Game(int i){
System.out.println("Game Constructor");
}
}
class BoardGame extends Game{
BoardGame(int i) {
super(i);
System.out.println("BoardGame constructor");
}
}
四、final关键字
package com.javabase.study.finalKeyWord;
import java.util.Random;
/**
* final数据：1、一个永不改变的编译时常量2、一个在运行时被初始化的值，而不希望它改变。
* 编译期常量必须是基本数据类型，且关键字是final。
* java允许空白final，声明为final但未给定初始化值，但编译器确保空白final在使用前必须被初始化。
* @author shining
*
*/
@SuppressWarnings("unused")
public class FinalData {
private static Random random=new Random();
private final int one=10;//编译期常量
private static final int TOW=12;//编译期常量
private final int three=random.nextInt();//运行期常量
public static final int FOUR=random.nextInt();//运行期初始化常量(加载时初始化)
private final int blankFinal;//空白final
public FinalData(int blankFinal) {
this.blankFinal = blankFinal;//对象创建时初始化
}
public FinalData() {
this.blankFinal=0;//对象创建时初始化
}
}
五、java多态特性
多态(动态绑定、后期绑定、运行时绑定)：发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。
绑定：将一个方法调用同一个方法主体关联起来。
前期绑定：在程序执行前进行绑定（由编译器进行绑定）。
动态绑定：运行时会传递某种类型信息，已便运行时候能找到对应的方法体。
java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
JVM实现机制，类实例的引用就是指向一个句柄（handle）的指针，这个句柄是一对指针： 一个指针指向一张表格，实际上这个表格也有两个指针（一个指针指向一个包含了对象的方法表，另外一个指向类对象，表明该对象所属的类型）； 另一个指针指向一块从java堆中为分配出来内存空间。 The Java Virtual Machine does not require any particular internal structure for objects. In Sun 's current implementation of the Java Virtual Machine, a reference to a class instance is a pointer to a handle that is itself a pair of pointers: one to a table containing the methods of the object and a pointer to the Class object that represents the type of the object, and the other to the memory allocated from the Java heap for the object data. （jvm规范中关于对象内存布局的说明）
六、ListIterator
package com.javabase.study.lists;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.ListIterator;
/**
* List迭代器，与Iterator不同的是，只能作用于List，并且可以双向迭代。
* @author shining
*
*/
public class ListIterators {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6,7,8,9,0));
ListIterator<Integer> it=list.listIterator();
while(it.hasNext()){//
System.out.println("向后1："+it.next());
}
while(it.hasPrevious()){
System.out.println("向前2："+it.previous());
}
it=list.listIterator(3);//从第四个元素开始迭代，并且只能使用一次
while(it.hasNext()){
System.out.println("向后3："+it.next());
}
//it=list.listIterator(5);如果没有重新给it确定迭代起始位置，那么将会是list全部元素。
while(it.hasPrevious()){
System.out.println("向前4："+it.previous());
it.set(10);
}
System.out.println(list);
}
}
七、Foreach
package com.javabase.study.lists;
import java.util.Iterator;
/**
* 通常for each作用于数组和Collection。
* Java SE5中添加一个Iterable接口，该接口包含产生Iterator的iterator(),
* 并且Iterable被foreach用来在序列中移动。因此实现Iterable的类，都能使用for each。
* 数组可以用for each，但是其不是Iteable实现。
* @author shining
*
*/
public class ForEach implements Iterable<String>{
private String[] words={"and","that","is","how","we","know","the","earth","to","be"};
public Iterator<String> iterator() {
return new Iterator<String>(){//匿名类
private int index=0;
public boolean hasNext() {
return index<words.length;
}
public String next() {
return words[index++];
}
public void remove() {
}
};
}
public static void main(String[] args) {
for(String s: new ForEach()){
System.out.println(s);
}
}
}
八、Exception中finally的使用
finally无论程序正常执行，还是遇到异常，return，break，continue都会被执行。
package com.javabase.study.Exception;
import java.io.BufferedReader;
import java.io.FileReader;
/**
* Throwable表示任何可以作为异常被抛出，分为两种类型：
* 1、Error用来表示编译时和系统错误
* 2、Exception代表可以抛出异常的基本类型。
* 构造器异常处理基本规则：在创建需要清理对象之后，立即进入一个try-finally语句块。
* @author shining
*
*/
public class ConstructorException {
public static void main(String[] args) {
try {
//构造器可能抛出异常，此时不用关闭流
BufferedReader reader=new BufferedReader(new FileReader("D:\\text.jav"));
try {
//business deal with
} catch (Exception e) {
System.out.println("other exception");
}finally{
try {
reader.close();//此时流是已经打开了必须关闭。
} catch (Exception e) {
System.out.println("close unsuccess");
}
}
} catch (Exception e) {
System.out.println("FileNotFound");
}
}
}
九、Class对象
package com.javabase.study.classLoader;
import java.util.Random;
/**
* 类是程序的一部分，每个类都有一个Class对象（在编译时期产生Class对象，保存在同名的.class文件中）
* 构造方法都static方法。
* 类加载过程：
* 1、加载：由类加载器执行，查找字节码，并且创建一个Class对象。
* 2、链接：验证字节码，为静态域分配空间，解析类创建对其他类的所有引用。
* 3、初始化：如果具有超类，则对其初始化，执行静态初始化器和静态初始化块。
* .class的引用不会初始化Class对象，forname()会进行初始化。
* 使用newInstance创建对象，必须带有默认构造器(可用)。
* 编译期常量无需进行类初始化就能直接访问，但是如果仅是静态变量，就会对类进行初始化Initable2.STATIC_FINAL
* @author shining
*
*/
@SuppressWarnings({"unused","unchecked"})
public class ClassLoaders {
public static Random rand=new Random(47);
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class initable=Initable.class;//不会进行初始化，因此不会输出静态块中的语句
//initable.newInstance();如果默认构造器是private的就无法进行创建。
System.out.println("After creating Initable ref");
System.out.println(Initable.STATIC_FINAL);
System.out.println(Initable.STATIC_FINAL2);
System.out.println(Initable2.staticFinal);
Class initable3=Class.forName("com.javabase.study.classLoader.Initable3");//进行初始化，输出静态块中的语句
System.out.println("After creating initable3 ref");
System.out.println(Initable3.STATIC_FINAL);
}
}
class Initable{
static final int STATIC_FINAL=47;
static final int STATIC_FINAL2=ClassLoaders.rand.nextInt(1000);
static{
System.out.println("Initalizing Initable");
}
//Exception in thread "main" java.lang.IllegalAccessException:
//Class com.javabase.study.classLoader.ClassLoaders can not
//access a member of class com.javabase.study.classLoader.Initable with modifiers "private"
// private Initable() {
// }
}
class Initable2{
static int staticFinal=147;
static{
System.out.println("Initalizing Initable2");
}
}
class Initable3{
static final int STATIC_FINAL=74;
static{
System.out.println("Initalizing Initable3");
}
}
分享到：
相关推荐
在Java编程语言中，"一切都是对象"这一概念是其核心特性之一。Java的设计目标是成为一种纯面向对象的语言，它在C++的基础上进一步优化，降低了复杂性，特别是在面向对象编程方面。与C++不同，Java不支持C语言那样的...
在Java中，一切都被视为对象，这意味着无论处理何种类型的数据，都可以使用相同的语法来进行操作。当我们提到“操纵对象”时，实际上是在操纵该对象的引用。引用类似于遥控器与电视机的关系：我们通过遥控器（引用）...
在JavaScript中，一切都是对象，包括基本类型（如字符串、数字、布尔值）在某些场景下也会被当作对象处理。下面将详细讲解这些知识点： 1. **变量**： - JavaScript中的变量使用`var`、`let`或`const`关键字声明。...
在JavaScript语言中，一切都是对象。因此，任何可以使用JavaScript原生语法表示的数据结构都可以用JSON表示。然而，JSON比JavaScript更简单、更纯粹，仅包括最常用的数据类型：数值、字符串、数组、对象（键值对）、...
在Java中，由于一切都是对象的引用，组合通常基于对象引用进行。组合的优势在于它保持了封装性，因为被包含对象的内部实现对外部是不可见的，实现了“黑盒”复用，增强了系统的灵活性和可扩展性。然而，组合可能导致...
一切皆对象是 Python 中的一个重要概念，类是对象，类的实例也是对象，模块是对象，函数也是对象。所有的一切都是对象。 在 Python 中，类的定义使用 class 语句，具体步骤是：在写完关键字 class 之后，就跟上类的...
对象是键值对的集合，可以通过点运算符或方括号运算符来访问其属性。原型链、构造函数、实例化和原型对象的概念是JavaScript对象模型的重要组成部分，手册会详细阐述这些内容。 在函数部分，手册可能涵盖函数的定义...
* Java 是一门面向对象的语言，它定义一切都是对象面向对象 * Java 学习的重要性在于它可以提高软件开发的效率和代码重用 知识点二：面向对象编程思想 * 面向对象编程思想是 Java 程序设计的核心思想 * 面向对象...
然而，与数字或字符串不同，对象是键值对的集合，可以通过属性（keys）和方法（functions）来访问和操作它们。 2. **构造函数**： 构造函数是创建对象的特殊函数，通常用于初始化新创建的对象。使用`new`关键字...
在JavaScript中，几乎一切都是对象，包括函数。这种特性使得JavaScript成为一门非常灵活的语言。 ##### 1. 数据类型 JavaScript中的数据类型可以分为两大类：基本数据类型和复杂数据类型（对象）。 - **基本数据...
Java语言是面向对象编程的典型代表，它的设计哲学便是"一切都是对象"。 **对象、类与实体** 1. **对象**：对象是面向对象编程中的基本单位，它代表了现实世界中一个具体的实体或者概念。在Java中，对象是类的实例...
JavaScript对象是JS编程中的核心概念，它是一种数据结构，用于存储和组织数据。在JavaScript中，一切都是对象，包括基本类型如字符串、数字和布尔值，它们都有对应的包装对象。理解JavaScript对象模型对于深入学习和...
对象是数据和处理这些数据的方法的封装体。在Objective-C中，一切皆为对象，即使是基本类型如整型或字符型也会被视为对象。OOP的核心理念包括： - **封装**：隐藏对象的内部状态，只通过公开的接口与外部交互。 - *...
组合可以通过引用或值实现，但Java中一切都是对象的引用。 **组合的优点**： 1. 容器类仅通过被包含对象的接口与其交互，保持了封装性。 2. 实现细节对外部隐藏，实现了“黑盒”复用。 3. 更好的可扩展性，因为对象...
在面向对象的世界里，一切都是对象。面向对象有三大特性：封装、继承和多态。 1. **封装**：隐藏对象的属性和实现细节，仅对外提供公共访问方式。这样做的好处是可以自由修改对象内部结构而不影响其他对象。 2. **...
在面向对象的世界里，一切都是对象，每个对象都有自己的属性和行为。 #### 二、类与对象 **类**：类是对象的模板或蓝图，定义了一组相似对象的共同特征和行为。它是抽象的，不能直接创建实例。 **对象**：对象是...
而在Python中，一切都是对象，类是通过`class`关键字定义，继承是通过冒号(`:`)表示，多态则是语言内置的特性。 通过学习面向对象程序设计，开发者可以构建更模块化、可维护的代码，更容易应对复杂的问题。PDG这...
在Qt中，一切都是对象，这是其设计哲学之一。Qt对象模型基于C++的面向对象特性，提供了一套完整的事件处理机制、信号与槽（Signals & Slots）通信机制、属性系统和元对象系统。信号与槽是Qt的核心特性，允许对象间...