零基础JAVA学习---------帮助别人就等于帮助自己,谢谢。
java数据类型
==========================
1基本类型
===================================
byte 1个字节(8位) {-128~127}(-2~7到2~7-1)
short 2个字节(16位) -2~15到2~15-1
int 4个字节(32位) -2~31到2~31-1
long 8个字节(64位) -2~63到2~63-1
float 4个字节 单精度
double 8个字节 双精度(美国工业电气协会浮点数表示规范)
char 2字节 (从0到2~16次方-1) 赋值都是字符或字符串
boolean 1个字节 true false
基本类型字面值
===========================
*整数字面值是int 类型
*byte short char 比int范围小的整数,允许用范围内的值直接赋值
*浮点数字面值是 double 类型
*字面值后缀
L long
long a = 999999999L;
F float
float a =3.14f;
D double
double a =3.0d;
*进制前缀
0x 16进制 一个16进制的数就是二进制的4位
0xff 表示 255
0 8进制 一个8进制的数就是二进制的3位
0377 转十进制 是255 (过程:3*8~2+7*8~1+7*8~0)
\u char类型 16进制
★基本类型运算规则★
=======================================
* 运算结果的数据类型,与运算项中范围最大的类型一致
* byte short char,比int范围小的整数运算时,会自动转成int类型
* 整数运算溢出
int a = Integer.MAX_VALUE;(int a 最大值表达式)
int a = Integer.MIN_VALUE;(int a 最小值表达式)
*浮点数运算的不精确
*浮点数的特殊值
Infinity 无穷大
Double.MAX_VALUE*2
NaN (Not a Number)
Math.sqrt(-2) 开平方 不是数
基本类型类型转换
=========================
*范围小的>范围大的
byte a = 127;
int b = a;
*范围大的>范围小的
需要强制转型
byte a = 255;
byte b = (byte)a; 回损失数据值
* import 导包
指明路径,后面代码中可以简写类名,而不必写全路径。
*String 用在字符串
String a = "你好";
String a = "A";
*调整代码缩进标准:快捷键 Ctrl+A 全选后 Ctrl+i
符号
&& 表示: 与
两侧都为真 结果为真;
有一侧为假 就过都为假;
||表示 :或
两侧同时为假 结果为假;
若随意一侧为假 结果都为真;
>> 带符号 右移位
符号位为0, 左侧就补0
符号位为1, 左侧就补1
>>> 不带符号右移位
不管符号位是0还是1,左侧都补0
<< 左移位,右侧补0
* 移位运算 不修改原值,新分配内存控件保存移动结果
*向右移动1位相当于/2
向左移动1位相当于*2
自增自减
++
--
int a =10;
System.out.println(a++); // a变成11,使用它的原值10
System.out.println(++a); // a变成11,使用它的新值11
三项运算
=========================
1?2:3
1是真,执行2
1是假,执行3
= 赋值运算
==============================
+=
-=
/=
>>=
^=
......
int a = 10;
a=a+3;
a+=3;
★在【0,1000)范围内产生随机整数
int a = new Random().nextInt(1000);//随机生成一个数字
流程控制
=============================
if_else else_if
switch_case_default
只能判断 byte,short,char,int,enum类型
当一个case成立,从这个case开始,无条件向后面执行每个case,直到结束。
switch(变量或表达式){
case 1 ://case后面只能写常量 或者是 数字 ,不能是表达式
case 2 :
case 3 :
case n :
default;//此处default 表示否则
}
for
for(定义变量;执行条件;修改变量){
}
for(int i =1;i<=10;i++){
System.out.println(i);
}
while
do_while
循环嵌套
==========================================
for(){
for(){
中断
==========================
break
中断跳出循环
continue
继续执行循环,跳过当前位置的程序
//获得输入的目标值
*int t = Integer.parseInt(et.getText().toString());
随机数产生(1——1000)
Math.random()...生成0.0到0.99999。。。。。(小于1)
Math.random()*1000.....0.0__999.9999
Math.random()*1000+1....1.0___1000.9999...
(int)(Math.random()*1000+1) 1——————1000
Math.sqrt(a) 表示a的开方值
循环命名
==============================
*嵌套的内层循环中,控制外层循环,需要给外出循环命名
outer:
for(;;){
for(;;){
语句;
if()break outer;
语句;
if() continue outer;
}
}
while
==========================
先判断 后执行
while(条件){
}
先执行一次 后判断
do-while
do{
}while(条件)
数组
=========================
*用来存放一组数据的数据结构
数组创建
----------------------------
1. int[] a = new int[5];
*5个位置都是默认值0
*new为数组新分配内存控件
*变量a保存的是数组的内存地址值
2.int []a={3,6,65,2,4,765,345,6};
3.为数组变量重新赋值
a = new int {5,3,45,2};
数组访问
--------------------------
a[0] = 743
int k = a[2];
print(a[3]*2)
数组长度属性
-----------------------
a.length
数组一旦创建,数组长度不可变
数组长度允许是0
int [] a = new int[0];
数组遍历
----------------------
遍历:从头到尾依次访问每一个位置
for(int i=0;i<a.length;i++){
a[i]
}
数组工具类 java.util.Arrays
-----------------------------
Arryays.copyOf(数组,长度)
将数组赋值成制定长度的新数组
Arrays.sort(数组)
优化的快速排序 算法
Arrays.toString(数组)
将数组中的值,连接成字符串
Arrays.bianrysearch(数组,目标值·)
二分法查找
在数组中寻找目标值的位置
如果找不到,返回负数
Arrays.fill(数组,值)
所有位置填充指定的值
数组复制
---------------------------
Arrays.copyOf(数组,长度)
System.arraycopy(原数组,原数组起始位置,目标数组,目标数组起始位置,长度)
二维数组
-------------------------------------------
*存放数组的数组
创建二维数组
---------------------
1 int[] [] a =new int[3][2];
*一共创建了4个数组:
一个外围数组,三个内部数组
*外围数组长度3,内部数组长度2
*在外围数组中,存放的内存地址
2 int [][] a = new int[3][];
只创建了一个外围数组,之后可以在创建一维数组放入
a[0] = new int[4];
a[1] = new int[2];
a[3] = new int[3];
3 int[][] a ={{6,3,5,7}{9,4}{1,5,3}};
二维数组访问
---------------------------------------------
a[][]
二维数组的遍历
-----------------------------------
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
a[i][j];
}
变量
===============================
*局部变量
定义在方法或局部代码块中的变量
*必须手动初始化(第一次赋值时,分配内存)
*局部变量作用域到它定义的大括号结束
*局部变量作用域范围内,不能重复定义
*成员变量
定义在类中的变量
*成员变量不必须手动初始化,可以自动初始化成默认值
*作用范围:
*类内部都能访问
*根据访问范围设置,在类外也可以调用
方法
-----------------------
*命名的代码块
*可以被重复调用
void f(int i,String s,double []a){
*方法可以有返回值
int f(){}
String f(){}
double f(){}
char [] f(){}
*void 空, 表示无返回值
*return
*返回到调用位置
*有返回值的方法,用return返回值
return xxx;
*void方法中,用return控制方法结束
return;
*递归
在方法中,调用自身
int f(){
f()
}
*一步步简化问题,将问题简化成最简问题,再倒退求出结果
*一般不同时做多次递归调用否则运算量会急剧增加
* 斐波那契
1 1 2 3 5 8 13 51 34 55 89。。//后一位都是前两位的和
面向对象
=========================================
*是一种人为抽象的编程模型
*复杂问题分解成一个个独立的小问题,通过单独解决每个小问题
三大特性:封装、继承、多态。
类
-------------------------------
*理解成“图纸”
*对事物、算法、逻辑、概念的抽象
*封装
将相关数据、代码,封装成一类组件
对象(实例)
---------------------------------
*理解成从“图纸”创建的“产品”
*每个对象占用独立的内存空间,来保存自己的属性数据
*每个对象可以独立控制让它执行制定方法的代码
引用
----------------------------------
*理解成“遥控器”
*引用变量保存一个对象的内存地址,通过引用,可以找到这个对象的存储空间,并调用它的成员。
*引用类型的特殊值: null
null 空,
表示不引用任何对象的内存地址
构造方法
---------------------------------
*新建实例时,执行的特殊方法。
new = Soldier()
new = FlashLight()
*一个类,必须有构造方法
*如果不定义构造方法,编译器编译代码时,会添加默认构造方法。
class A{
public A(){
}
}
*构造法重载
class A{
public A(){
}
public A(int i){
}
pubilc A(int i,String s){
}
}
*构造方法之间调用
用 this(...) 减少代码重复
public Student(int id,String name){
this(id,name,null);//调用只用前两个,不用的用null或0代替
}
public Student(int id,String name,String gender){
this.id=id;
this.name=name;
this.gender=gender;
this
------------------------------------------
*两种用法
*引用当前对象,保存当前对象的内存地址
格式 this.xxx
f(this)
A a=this;
*构造方法调用
this(....)的注意点
*必须是首行代码
java的参数传递-传值
=============================================
*基本类型变量,是值本身
int a =10;
f(a); int a = 10;
f(a);//取出a的值,传递到f()方法的参数变量
print(a);//打印10
......
void f(int a){
a = 100;
}
*引用类型变量中的值,是内存地址
main(){
Point a = new Point(3,4);
f(a);//a的值是内存地址,将内存地址传递到f()方法
print(a.x);//30
print(a.y);//40
}
f(Point a){//参数a引用上面那个 对象的地址
a.x = 30;
a.y = 40;
}
重载 overload
----------------------------------
*同名不同参
继承
=========================================
*作用:代码重用,代码复用
*单继承:
*子类,只有一个父类
*父类,可有多个子类
*子类,可以隔层继承多个父类
*重写 override
*从父类继承的方法,不满足子类需要,可以在子类中重新编写这个方法
*重写一个方法时,可以用super.xxx()调用父类同一个方法的代码
*创建子类对象
先创建父类对象,执行父类构造方法
在创建子类对象,执行子类构造方法
*两个对象绑定在一起,整体作为一个子类对象
*调用成员时,先找子类,再找父类
*创建子类对象时,先执行父类构造方法
*默认执行父类无参数构造方法
super()
super
=================================
*两种用法
*重写时,调用父类同一个方法
public String toString(){
.....
super.toString()
.....}
*手动调用父类构造方法
super(参数)
*必须是首行代码
多态
--------------------------------------
作用一致的类型
*类型转换
*向上转型
子类对象,转换成父类型
*向下转型
已经转为父类型的子类对象,再转回成子类型
instanceof
---------------------
判断一个对象的类型
s instanceof line true;
抽象类
=======================================
*抽象类是半成品类,没有完成的类
*作用:
*为子类提供通用代码
*为子类提供通用方法的定义
*抽象类不能创建实例,只能创建他子类的实例
*包含抽象方法的类,必须是抽象类
抽象类中,不一定包含抽象方法
final
==========================================
*修饰变量、方法、类
变量
----------------------------------
*变量的值不可变,成为“常量”
*基本类型的值,是值本身不可变
*引用类型的值,是引用的地址不可变
final int a = 10;
a=11;//错的
final Point a = new Point(3,4)
a.x = 30;//对的
a= new Point(1,5)//错
a= null//错
final 方法
---------------------------------------
*方法不能子类重写
final 类
*不能被继承
static
=======================================
* 静态
*静态成员属于类, 而不属于实例
class Soldier{
int id;
}
*调用静态成员,应该使用类名调用
Soldier s1= new Soldier();
Soldier s2= new Soldier();
//下面代码容易误解
s1.count =1;
s2.count =2;
print(s1.count)
Soldier.count= 3;
print(Soldier.count)
*什么时候用静态
*使用原则:能不用就不用
静态是“非面向对象”的语法
*使用场景:
*实例间共享的数据
*工具方法
Math.sqrt()
*静态方法中,不能调用非静态成员
static 构造方法下 不能调用非静态方法
在静态方法下 可以调用静态方法
*静态初始化块
class A{
static{
}
}
*第一次用到A类,加载A类时,只执行一次
常量
*static final
*命名习惯:全大写,单词间加下划线
static final int MAX_VALUE =100;
对象创建过程
--------------------------------------
class A{
int v1 =1;
static int v2 =2;
static{
...
}
public A(){
...
}
}
-----------------------
B b = new B();
第一次用到A类和B类
1加载父类,为父类静态成员变量分配内存
2加载子类,为子类静态成员变量分配内存
3执行父类静态变量赋值运算,变执行静态初始代码块
4执行子类静态变量赋值运算,变执行静态初始代码块
再次用到A类和B类
5创建父类对象,为父类非静态变量分配内存
6创建子类对象,为父类非静态变量分配内存
7执行父类非静态变量赋值运算
8执行父类构造方法
9执行子类非静态变量赋值运算
10执行子类构造方法
访问控制符
=======================================
*控制类和类中的成员的访问范围
pubilc
pritected
[detault]
private
如何选择访问控制符
原则:尽量使用小范围
public是与其他开发者的契约,约定公开的定西会保存稳定不变
private 隐藏,便于代码的维护和修改,不会
接口
======================================
*作用:结构设计工具,用来解耦合
*是极端的抽象类
*用interface 代替class关键字
*用 implements代替extends关键字
*接口中只能定义
公开的常量
公开的抽象方法
公开的内部类、内部接口
*一个类可以同时多个接口
class A implements B,C,D{
}
class A exteds B implements C,D,E{
}
*接口之间继承
一个接口 可以继承多个其他的父接口
interface A extends B,C,D{
}
内部类
==================================
*定义在类内部、方法内部、局部代码块内部
*非静态内部类
依赖与外部类实例存在
*非静态内部类中,不能定义静态成员
class A{
class Inner{
}
}
A a = new A();
aInner i = a.new Inner();
*静态内部类
class A{
static class Inner{
}
}
A.Inner i =new A.Inner();
*局部内部类
*局部定义的类型,只能在局部使用
class A{
void f(){
class Inner{
}
Inner i = new Inner();
}
}
------
A a = new A();
*匿名内部类
Weapon w = new Weapon(){...}
*大括号是匿名类
*new 新建匿名类实例
这个笔记还没整理完全,后期持续更新,对于大神来说肯定很简单,但是对于初期学习的人应该有帮助,和大家一起共勉。