java 数据类型和堆栈 类

2019独角兽企业重金招聘Python工程师标准>>>

一篇简单的文章作为自己转型的开始，以后由嵌入式开发转向安卓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(映射)接口:

转载于:https://my.oschina.net/u/274829/blog/293670