零基础学习ＪＡＶＡ的初期笔记－－自己的笔记

零基础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[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

for(int j=0;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 新建匿名类实例

这个笔记还没整理完全，后期持续更新，对于大神来说肯定很简单，但是对于初期学习的人应该有帮助，和大家一起共勉。