java基础语法（本人学习java的笔记）

基本语法部分

为选定的行改为注释：

shift+方向键  选定数行内容

ctrl+/   

 

想解绑哪一行的话，同样使用ctrl+/   

常量：final 数据类型

输入赋值：

int 变量名；

 Scanner in=new Scanner(System.in);

变量名=in.nextint（）；

数据类型强制转换：

（数据类型名） 变量名

if  else：

else语句总与最近的if匹配；

math.random()   这个函数可以随机产生一个【0,1）的数

可以通过*100  *1000  的方法改变随机取值范围；

要转换成整数，可以*100后再强制转换类型

对输出结果进行位数控制：

system。out。printf（“%。2f”，i）；

数组定义：

数据类型【】  数组名=new  int【数组大小】

直接赋值与c相同。

防止数组溢出的方法：

先让用户输入个数，在定义数组。

for。。。。。each循环：

for（int  k：data）  //在这个for循环中，每一次使用数组名为data的一个值k进行运算。

boolean   布尔类型

\ 的类型：

\r   回车；

\"   双引号

\'   单引号

\\   斜杠

\t   制表符

string   s为大写；

一个字符串类型的变量加上一个不是字符串类型的值，自动转换为字符串。

in.next()  //读入一个值

in.nextline()    //读入一行

字符串操作：

比较字符串：

.equals(比较值)

length（）  字符串长度；

charAt(index)   //获取该字符串的某一个字符。

s.substring(n)    //得到从n开始的到结尾的全部内容。

s.substring(b,e)     //得到从b开始的到e位之前的内容。

s.indx0f(c)     //从右边开始找c所在的位置，-1表示不存在

s.index0f(c,n)    // 从n开始找c的位置。

s.replace(c,n)     //用c2的内容替换c1的内容

s.toLowerCase()    //   替换为小写

s.toUpperCase()    //替换为大写

数学函数操作；

math.abs()    // 绝对值

math.pow()   //幂次

math.random()    //

math.round()     //

传值时，宽的值兼容窄的值。

char--》int---》double

传值与穿址：

数组传址；

string传值；

 

super() 

 //

"super"。它和"this"类似，但是也有不同的地方。 
1。表示调用父类的构造函数。也是一个特殊语法，不是变量，没有什么类型。

2。可以在一个类的非static成员内部使用。比如super.method()。 
但是，注意，这个super.method()只是长得跟some_var.method()一样，一个语法糖而已。实质上，"super"根本不是一个变量。

为什么不是？因为如果是就坏了。java里面有一个金科玉律：任何public非static函数的调用都是多态的。 
所以，如果super是个变量，也指向当前对象，那么，不管super的静态类型是什么super.method()必然调用的是子类的那个版本，而不会是我们期望的，静态地选择父类的那个版本。

所以，你只要把super.xxx看成一个特殊的语法，比如理解为“super::xxx”就好了。

既然super不是一个变量，那么不能把它象一个普通变量那样"=="，或者传递给某个函数就看起来很正常了，是么？何况，你其实也用不着它，有this你这些要求就都可以办到了。

3。super的另外一个作用是调用父类的protected函数。只有通过"super"这个魔咒，我们才能操作父类的protected成员，别无它法。

在定义类时候，内部的this表示该类实例。

封装类的属性的写入与读取：

 

绘图类：

 

 

 

绘制多边形:

 

 

java架构：

 

 

jvm：java虚拟机

 

java环境配置

dos命令行：

 

rd  删除文件夹，必须保持文件夹保持空的状态。

del  可以通配符删除文件

帮助：  help  内容

 

系统根目录：即指系统盘的windows目录

 

去某一个盘：

配置环境变量：

电脑--》属性--》高级--》环境变量-》path   把要加路径与其它路径用“；”分割；

 

环境变量重新配置后，需要重启命令行程序；

临时配置java环境：

 

使用cmd命令行工具修改环境变量，只在本cmd下有效。

 

set path=........ 修改环境变量

set path=........%path%    //在原有环境变量基础上添加新的值。

 

 

 

 

新纪录：2015.11.17

变量类型：

 

变量命名规范：

 

path：java所在的路径

classpath：java类型的类文件的路径

 

java运行过程：

javac   java文件

java   class文件（不用加class后缀）

数据类型：

 

布尔型：boolean

 

字符型:

大写a是65

小写97

 

jav使用Unicode字符集

Unicode中一个中文字符与一个英文字符占用大小相同

 

浮点型：

 

 

整数类型：

逻辑运算符：

 

if

else if

else if

else

 

switch：

 

循环：

ctrl+c   强制停止

对象

 

对象：关于类的内存：

 

匿名对象：

 

构造函数：

不写系统会为你自动添加

 

 

构造函数在new时触发。

 

 

 

较多传入值时，可通过重载构造函数。

this：

本类的字段和方法使用this字段。

 

调用方法和字段的对象使用this代指。

 

静态：

不可使用this；

使用类名，对象名皆可；

 

静态函数中，不可引用非静态的字段或方法。

 

 

静态属性，字段，所有该类对象公用，如上图。

 

 

静态代码块：

装载类时执行；无需调用。

 

继承：

关键字：extends

 

如下图：

注：即自动函数（如果父类没有构造函数）；

 

为什幺调用父类构造函数？好处是什么？

因为无法继承构造函数。

 

如果想调用父类中的其他构造函数，在super（）的括号中输入参数即可；

 

函数复写或重写（override）：

对父类的函数复写：

函数的代码块改变；

子类覆盖父类；

 

super的用法：

super.函数      //调用父类的函数，有重写时使用。

 主函数入口：

 

 

对象转型：

 

向上转型：

 

向上转型：把子类传给父类；

 

 

 

如下图：

person类没有address属性，而student有该属性；

向上引用只能使用子类和父类皆有的字段名和函数名，且使用的是子类的字段和函数内容（相当于复写父类函数）；

 

向下转型：

 

如何应对「这种办法不是多余的么」的说法？

举例：超市里的泡面吃的时候不需要包装，我们想买的只是面饼，但厂家还对我们想要的东西进行了包装。不了解就不应该想当然，多了解。

 

为什么可以强制转换？

因为p已经指向student，他是一个潜在的student对象，强制转换只不过是把他的伪装撕破而已。

 

编译所有java文件：   javac   *.java

 

抽象类和抽象函数：

abstract  void  fun（）；

//抽象函数没有函数体

 

抽象类亦被称为基类；

 

有抽象函数的类必须为抽象类，没有抽象函数依然可以声明抽象类；

 

抽象类不能生成对象；

 

抽象类天生是当爹的，只被继承；

继承抽象类的类需要复写重写抽象函数，避免无法生成的问题；

 

子类的生成时可以调用抽象类的构造函数；

 

 

 

 关于抽象基类使用抽象函数的作用：

如果一个子类需要一个函数，而这个函数在父类中为抽象函数。如果忘记复写函数，在执行的时候，会报错。

 

包和访问权限：

 

包：

 

 

编译时注意：

 

注： “-d”指的是目录，“.”指的是当前目录下；

即指在但前目录生成包文件夹，并编译文件；

 

 

包名的命名规范：

注：类似于org.marsdroid的包名，会先生成一个org文件夹，在其下面生成marsdroid文件夹，class文件会在其下；有点多一级；

 

访问权限：

 

 

 

如果想访问方法和属性，字段，也应该使用public权限。

 

private  通常情况下只修饰方法和属性，字段。

只能在声明类中使用。

 

不声明范围默认default，权限为包级别。

 

 

在不同包中声明类时，要带上包名。

 

 

技巧：

如果包名很长，声明类时比较麻烦，可以事先声明包.类（命名空间），在下面声明类时，不需要带包名了。

ex：

 

另外：

如果需要使用一个包中的多个类还可以进一步简便：

ex:

 

包和继承：

 

 

protected权限：

 

注：protected权限允许跨包访问属性，函数权限（限于子父类）。

 

权限排名：

public 

protected

default

private
技巧：

批量编译：

javac  *.java

接口：

interface

继承接口使用implement关键字

称为实现了接口

该类称为实现类

 

多重实现：

 

接口继承接口:

可以多继承：

 

 

 

 

工厂方法模式：

 

在工厂模式中，在实现接口向上转型中，要先声明接口，不初始化（抽象类不能实例化）；

详见转型部分

异常

异常是在执行时出现的错误，不是语法错误。

例如计算1/0。

 

 

关于try......catch：

 

 

 

throw与throws：

 

 

 

I/O（input与output）：

 

I/O核心类：

字节流：

 

核心方法：

read方法的返回值为该次读取了多少个字节；

如果read已经读取完文件，则返回-1；

 

 

简写：

fis

fos

 

注：b指下标开始，5即指从下标5那个开始；len指长度；

 

注意：

 

代码：

 

字符转化为字符串：

 

注：关于trim方法：

 

大文件的读写方法：

 分次读取写入：

示意：

 

代码如下：

 

 关闭I/O流：

fis.close();

注：

要放在finally里；防止try中出现问题，不能正常关闭；

 

字符流：

 

代码：

 

代码：

import java.io.*;

class TestIo{

    public static void main(String arge []){

        FileReader frd = null;

        FileWriter fwt = null;

 

         //io操作必须捕捉异常

        try{

            frd = new FileReader("d:/report_data2.txt");

            fwt = new FileWriter("d:/123.txt"); 

            char[] buffer = new char[100];

            int temp = 0;

            while(temp != -1){

                temp = frd.read(buffer,0,buffer.length);

                fwt.write(buffer,0,temp);

                System.out.println("ffffff");

            }

       

        }

        catch(IOException e){

            e.printStackTrace();

        }

        finally{

            try{

                frd.close();

                fwt.close();

               

            }    

            catch(IOException e){

            System.out.println(e);

            }

        }

    }

}    

节点流&处理流：

BufferedReader：   //处理流

readLine():  //读取一行数据

 

 

代码：

注：

参见装饰者模式，bufferedReader为装饰者，fileReader为被装饰者；

bufferedReader使fileReader可以成行读取数据，增强操作；

 

装饰者模式：

 

 

注：Plumber，Carpenter都实现了Worker接口；

 

内部类

 

编译结果：

生成内部类：

或者：

在a的基础上生成内部类b，b可以使用a

注：内部类可以使用外部类的方法和属性；但不是继承；

 

匿名内部类：

注：new A是声明一个实现A接口的实现类，只不过该类没有名字；

类如：向上转型：file = new IoFile();   

 

线程

进程和线程：

 

注：cpu时间轮盘切走，回到runnable状态；

 

创建线程：

 

第一种方法：

 

启动线程：

.start();

 

注：

注:这样写是执行类的run方法，而不是启动线程；

 区别：

执行run：

执行start：

 

实现线程的第二种方法：

线程与线程体分离：

代码：

RunnableImpl类：

 

 线程的一些简单的线程控制方法：

注：sleep();Thread为静态类；

1000毫秒为一秒；

当sleep时间完成时，重新回到准备状态；

 

yield方法执行让出cpu，回到准备状态；

 

显示优先级：getpriority  int类型

设置优先级：setPriority（）

最大优先级：

最小优先级：

等级:

注：

 优先级越高，执行的概率越高；

 

setName()和getName():

 

currentThread():

获取当前正在执行的线程

 

 线程间同步：

同步锁：

或者：

注：一个线程取得同步锁权限后，在执行同步锁范围内的代码时，其它线程如果取得cpu也许等待执行完毕；

 

 

synchronized关键字：

 注：锁住的并非代码块，而是对象；

一旦一个线程获取了同步锁对象，那么其它线程不能执行该对象的其它需要同步锁的代码；

ex：

注：该类被赋予给了两个线程，线程1拿到this同步锁，执行sleeep代码；线程2获得cpu，但因为线程1拿到锁，所以线程2不能执行该this对象的fun2下的同步锁包含的代码块；

 

数组

及

注:中括号写在变量名前面亦可；

 

.length  // 数组长度

int arr[ ][ ] = 

 

二维数组：

 

类集框架

 

类集框架主体结构：

注:集合内容不允许重复，列表可以；

 

集合（Set）：

 

列表（List）：

 

映射  键值对（Map）：

 

关于List（ArrayList）：

 

获取及移除：

注：从零开始

 

长度:

 

代码示例：

 

Collection：

 

 

 

Set（集合):

实现类HashSet：

注:集合没有顺序；

 

迭代器（取得集合中的元素）：

注:因为List也继承了迭代器，所以也可以使用迭代器遍历List；

注: 需要导入接口；

代码：

注:hasNest()   //下一个元素是否为空

 

Map（键值对）

实现类HashMap：

 

 

常用方法：

 

声明及使用：