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