零基础学习JAVA的初期笔记--自己的笔记

零基础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 新建匿名类实例




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


你可能感兴趣的:(JAVA)