java 数据类型和堆栈 类

一篇简单的文章做为本身转型的开始，之后由嵌入式开发转向安卓app开发

javaee企业版

javase 标准板，作桌面应用程序

javame小型版，针对小产品，好比手机(这个已经不用了，如今用的是安卓)

java输出

System.out.print(a);

print只是输出‘字符’和“字符串”和 变量 

print('a'+1) 变为输出 98 ‘a'的ASCII为97。print(’你‘+1)；由于汉字也是存放表中

java不一样数据类型运算注意事项

java数据类型分为byte 1个字节 short 两个字节 int 4个字节 long 8个字节  float 4个字节 double 8个字节 char两个字节

byte b = 4;  //将int型 4对比是否符合前面数据类型的范围，符合则自动转换为byte型

b = 4 +6;  // 这里也是将int型 先比较计算结果是否超过变量范围，没超自动转换为byte类型，超了报错

byte b1 = 3;

byte b2 = 4;

b = b1 +b2;  //这个会报错，丢失精度，由于b1和b2为变量，无法肯定计算结果是否会超过自己范围

同理若是上面改成

b = b1 + 10;   //也是报错，由于b1是变量，值不肯定，加上数会超范围

同理改成 

b = b1 - 3;     //也是报错由于 byte减int无法进行

同理

int b = 10;

byte c = 9;

b = b - c ;   //ok 

c = b - c;   //报错。由于可能相减的值仍会比byte范围大。

    

int x;

x = b1 + b2;   //能够。由于int型范围大于byte，byte的计算结果不会超出int型的范围。

int x1 = Integer.VALUE;

int x2 = 2;

x = x1 + x2;    //这个虽然运算结果会超过范围，可是编译时不会报错，由于同类型，运算结果超出时结果是负数。

while(true)  //while循环只能是(true/false)    不能够和c语言同样while(1);

{

}

java字符串链接做用 

print("a" + 3);

输出a3

int a = 4;

int b = 5;

pirnt(a+b);   //获得9，没有到字符串链接，就是进行计算

print("a" + a + b);  //获得a45

print("a" + 4 + 5);  //获得a45

若是想要进行运算就加括号，括号保证了运行顺序，先进行加法运算，后进行字符链接。

print("a" + (4 + 5) );  //结果为 a9

堆栈 数组简介

栈，函数中的局部变量；变量所属区域运行完成，自动释放；

堆：new出来的数组和方法；内存垃圾自动回收，不用程序员释放；

public static void main ()

{

    int[] arr = new int[3];

    System.out.print(arr);   //获得 [I@1de17f4  ；这是arr地址

    System.out.print(arr[0]);  //输出arr数组第一个元素

    arr = null;   //arr指向空，断开链接堆链接，释放了堆内存

}

程序运行过程：将main函数压栈导入内存，而后运行到arr压栈，arr有边是堆，堆默认对值进行初始化，会有本身的起始地址，栈中的变量会引用这个地址找到堆中的存储区。

面向过程与面向对象区别

面向过程，一步步执行完想要操做的动做；

面向过程，先建立一个对象，这个对象具备完成这些动做的特性，像上图对象冰箱 能够打开 存储 关闭，调用对象来完成本身的需求；

java类 

用于描述事物：1是属性(成员变量整个类能够使用)，2是行为(成员函数)；局部变量在一个局部中用

成员变量和局部变量的区别：

1，成员变量定义在类中，整个类中均可以访问。

     局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。

2   成员变量存在于堆内存的对象中。

     局部变量存在于栈内存的方法中。

3  成员变量随着对象的建立而存在，随着对象的消失而消失。

    局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

4  成员变量都有默认初始化值。

    局部变量没有默认初始化值。 

封装

封装是为了将变量隐藏，起到保护做用；提供方法供外部试用，还有修改方便

class Person
{
	private int age;	 //只有本类能够使用，这样就能够加限制条件，防止误操做 如输入 -20

	public static void setAge(int i)
	{
            if(i < 0 ) {   //这样就能够限制范围，防止误操做了
                System.out.println("输入错误");                
            } else {
                age = i;
            }
	}
	public static void getAge()
	{
		return age;	
	}
	public void speak()
	{
		System.out.println(age);
	}
}

构造函数

构造函数：构建创造对象时调用的函数。做用：能够给对象进行初始化。构造函数能够有多个，用于对不一样的对象进行针对性的初始化。这也就是重载的概念。建立对象都必需要经过构造函数初始化，若是没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。若是在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

通常函数和构造函数什么区别呢？

构造函数：对象建立时，就会调用与之对应的构造函数，对对象进行初始化。

通常函数：对象建立后，须要函数功能时才调用。 

构造函数：对象建立时，会调用只调用一次。

通常函数：对象建立后，能够被调用屡次。

class Person
{
	private String name;
	private int age;

	//定义一个Person类的构造函数。
	Person()//构造函数，并且是空参数的。
	{
		
		name = "baby";
		age = 1;
		System.out.println("person run");

	}
}

class test
{
    public static void main(String[] args)
    {
        Person p = new Person();  //编译运行后，会输出 person run 由于构建函数，对象建立时调用
    }
}

this

1，当成员变量和局部变量同名时，能够用this区别。

2，当构造函数中调用本类其余构造函数时，能够用this完成。

this从某个构造函数调用同一个类的另一个构造函数。this表明本类对象的引用，this()必须是第一行语句

super表明一个父类空间

class employee
{
    private String name;
    private int    age;
    employee(String name,int age)
	{
		this.name = name;        //参数name赋给类的名字
		this.age = age;          //参数age赋给类的年龄
	}
}

class gou
{
	private int num = 4;
        
        gou()
        {
            //super();  默认第一句是super()，调用父类的构造函数
            System.out.println("默认构造函数");
        }
        gou(int number)
        {
           //里面默认的第一句话是 super(); 调用父类的构造函数
           this();       //这个调用上面本类的构造函数  若是不写的话 默认 super调用父类构造函数
           num = number;
           System.out.println(num);
        }
	
}


class ce extends gou
{
    public static void main(String[] args)
    {
        ce p = new ce(20);  //编译运行后，会输出 默认构造函数 20
    }
}

static 

static修饰的变量，类能够直接访问，在内存中分配一块区域，供整个类通用，全部的类的对象都享有它的共同的值

class  Test { 
Static int i = 47; 
}

Test t1 = new Test();

Test t2 = new Test();

t1,t2两个对象的实例对象 i 共用一个内存 i = 47；

static静态代码块

class StaticCode
{
	static int num ;
	static    //静态代码块
	{
		num = 10;
		System.out.println("this is static code");
	}
	static void show()
	{
		System.out.println(num);
	}
}

class a 
{
        static
        {
            System.out.println("zhu stitic");
        }
	public static void main(String[] args) 
	{

		new StaticCode().show();
		new StaticCode().show();
		StaticCode.show();
	}
}

静态代码块:随着类的加载而执行。并且只执行一次

输出结果为：

zhu static                    //这个由于主函数先运行    this()   就会调用静态代码块

this is static code       //建立对象时应用 只引用一次

10

10

10

代码块

class StaticCode
{
	static int num ;
	
	{   //构造代码块
		num = 10;
		System.out.println("this is static code");
	}
	static void show()
	{
		System.out.println(num);
	}
}

class a 
{
	public static void main(String[] args) 
	{

		new StaticCode().show();
		new StaticCode().show();
		StaticCode.show();
	}
}

输出结果：

this is static code       //建立对象时引用一次

10

this is static code       //建立对象时引用一次

10

10                      //没建立对象因此没有引用代码块

static的特色：

1，static是一个修饰符，用于修饰成员。

2，static修饰的成员被全部的对象所共享。

3，static优先于对象存在，由于static的成员随着类的加载就已经存在了。 

4，static修饰的成员多了一种调用方式，就能够直接被类名所调用 。 类名.静态成员 。

5，static修饰的数据是共享数据，对象中的存储的是特有数据。

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

1，两个变量的生命周期不一样。

成员变量随着对象的建立而存在，随着对象的被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2，调用方式不一样。

成员变量只能被对象调用。

静态变量能够被对象调用，还能够被类名调用。

3，别名不一样。

成员变量也称为实例变量。

静态变量称为类变量。 

4，数据存储位置不一样。

成员变量数据存储在堆内存的对象中，因此也叫对象的特有数据.

静态变量数据存储在方法区(共享数据区)的静态区，因此也叫对象的共享数据.

静态使用的注意事项：

1，静态方法只能访问静态成员。(非静态既能够访问静态，又能够访问非静态)

2，静态方法中不能够使用this或者super关键字。

3，主函数是静态的。

final

final定义的变量能够看作一个常量，不能被改变； 
final定义的方法不能被覆盖； 
final定义的类不能被继承。

final static 就是再加上static的特性就能够了

集合类

集合即容器，用来存放数据的，数组存放数据长度固定的数据。数据长度不固定的用集合。

集合包含两个集合：collection接口，包含基本操做，添加、删除、遍历等，包含set(集)子接口，list(列表)子接口（ArrayList)

map(映射)接口: