java学习笔记

Java是一种强类型语言，在分配内存的时候不要忘记了加类型
Java中只能含有一个public类，一个主函数，而且文件名称和public类名相同

第一章 一些简单的知识

1、快捷键：

Ctrl+x :剪切
Ctrl +a :全选
Ctrl +y:重做
ctrl+end 定位到行尾
Ctrl+home 定位到行首
shift+end 选中当前位置到行尾操作
shift+home 选中当前位置到行首操作
ctrl+方向键 按单词递进
Windows +R :运行对话框
service.msc:服务
notepad:记事本
Calc:计算器
Tab: //制表符
Shift //上档键，反向操作
`` //引用标识符
/r //return 回车
/n //line 换行
/t //table 制表符
// 表示反斜杠字符
d //表示八进制
xd // 表示十六进制字符
un //表示unicode字符

2、dos命令

dir: directeroy
d: 切换盘符
tab: 补全按键
cd: 进入目录
mkdir: mkdir/make directory 创建目录
… 上级目录
. 当前目录
cp copy
del 删除文件 del a.txt /s/q/f *.class
-s : 递归删除整个目录
-q : 安静模式
-f : force 强制删除

mv 移动
rmdir 删除目录
ipconfig 查看ip地址
/? 帮助
ping 查看网络连通情况 127.0.0.1==localhost 自回环，Ping本
把自己的ip地址取个别名：
C:windowssystem32drivershostd文件
[host]
…
ip 别名
… #就可以通过ping别名，访问ip#通过这个配置hosts文件，可以绕过dns解析，上外网
set: 列出所有的环境变量
-version 查看版本
-verbose 查看详细信息
echo %path% 打印环境变量
rename 旧名 新名 #文件重命名 ‘
mv filename … // 把filename移到上一层结构上

3、关于java小知识

Java ee:企业版，为企业环境下的应用程序提供的一整套解决方案
Java se:为开发普通桌面的商务应用程序提供的解决方案
Java me:为开发电子消费产品的嵌入式设备提供的解决方案
JRE:包括java虚拟机和java程序所需的核心类库等，如果只是想运行一个java程序，jre就够了
JDK:提供给java开发人员使用的，其中包含java开发工具也包含了jre。其中的开发工具， 编译工具（javac.exe）和打包工具（jar.exe）
Java运行机制：
编写源代码.java -> javac:编译源代码.class -> java 运行代码

4、关于环境变量

set //可以临时配置环境变量，只在当前的dos 操作符下有效
set 变量名：查看具体一个环境变量的值
set 变量名=：清空一个环境变量的值
set 变量名=具体值：给指定变量定义具体指
配置临时环境变量：
set path=新值；%path%
classpath :把环境变量指定到classpath 的路径中。运行时，要在当前路径下找。加入路径，加入搜索路径。如果有两个同名的类名class文件，默认是越上层的越先执行。如果设置了classpath = 路径1；路径2，按着路径的顺序搜索。一般最后一个是当前路径。

5、java 中常见的关键字

class :类
interface : 接口
byte :8位
short: 2个字节
int: 4个字节
long: 8个字节
float: 浮点型 4个字节
Double: 双精度浮点型，默认是双精度
Char:字符型，两个字节，java中的字符属于unicide编码
Bool：布尔型，一个字节，两个值，0或1
除去这八个数据类型，其他的都是引用数据类型，比如string ,enum
Enum:枚举类型，需要代表一系列固定的常量，就可以使用枚举类型：
enum Season{春，夏，秋，冬}，相当于一个类
void: 空
null: 空，表示不存在
switch: 开关语句
case: 情况，后面常常接break
default: 默认
访问权修饰：private,protected,public
定义类，函数，变量的修饰符: abstract(如果一个类是抽象的，则这个类不能实例化), final（终极的）, static（静态的）, synchronized（同步，在多线程的时候使用）,extends（扩展）,implements（实现）
public：所有的类都可以访问该字段
private：只有该字段的类内部可以访问该字段
protected：受保护的
定义类，函数，变量的修饰符：
abstract(如果一个类是抽象的，则这个类不能实例化),
final（终极的）
static（静态的）：我们通常将用static修饰的成员称为类成员或者静态成员，它可以修饰成员变量和方法，来让它们变成类的所属，而不是对象的所属。虽然我们看到static可以让对象共享属性，但是实际中我们很少这么用。因为这样会让该属性变得难以控制，因为它在任何地方都有可能被改变。如果我们想共享属性，一般我们会采用其他的办法：

public class Person {
private static int count = 0;
int id;
String name;
int age;
public Person() {
id = ++count;
}
public String toString() {
return "Id:" + id + ", Name:" + name + ", Age:" + age;
}
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "zhangsan";
p1.age = 10;
Person p2 = new Person();
p2.name = "lisi";
p2.age = 12;
System.out.println(p1);
System.out.println(p2);
}

上面的代码起到了给Person的对象创建一个唯一id以及记录总数的作用，其中count由static修饰，是Person类的成员属性，每次创建一个Person对象，就会使该属性自加1然后赋给对象的id属性，这样，count属性记录了创建Person对象的总数，由于count使用了private修饰，所以从类外面无法随意改变。把count放在构造函数里，把count的值赋给另外一个变量，改变的是另外一个变量，不会对private修饰的count进行改变。
static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗。package com.dotgua.study;
static修饰静态块：

class Book{
public Book(String msg) {
System.out.println(msg);
}
}
public class Person {
Book book1 = new Book("book1成员变量初始化");
static Book book2 = new Book("static成员book2成员变量初始化");
public Person(String msg) {
System.out.println(msg);
}
Book book3 = new Book("book3成员变量初始化");
static Book book4 = new Book("static成员book4成员变量初始化");
public static void main(String[] args) {
Person p1 = new Person("p1初始化");
}
/**Output
* static成员book2成员变量初始化
* static成员book4成员变量初始化
* book1成员变量初始化
* book3成员变量初始化
* p1初始化
*///~
}

上面的例子中，Person类中组合了四个Book成员变量，两个是普通成员，两个是static修饰的类成员。注意，此时的booki是成员，不是对象，是指向对象的person成员。我们可以看到，当我们new一个Person对象时，static修饰的成员变量首先被初始化，随后是普通成员，最后调用Person类的构造方法完成初始化。也就是说，在创建对象时，static修饰的成员会首先被初始化，而且我们还可以看到，如果有多个static修饰的成员，那么会按照他们的先后位置进行初始化。
实际上，static定义的成员，在没有对对象进行实例化之前，就已经被定义了：

class Book{
public Book(String msg) {
System.out.println(msg);
}
}
public class Person {
Book book1 = new Book("book1成员变量初始化");
static Book book2 = new Book("static成员book2成员变量初始化");
public Person(String msg) {
System.out.println(msg);
}
Book book3 = new Book("book3成员变量初始化");
static Book book4 = new Book("static成员book4成员变量初始化");
public static void funStatic() {
System.out.println("static修饰的funStatic方法");
}
public static void main(String[] args) {
Person.funStatic();
System.out.println("****************");
Person p1 = new Person("p1初始化");
}
/**Output
* static成员book2成员变量初始化
* static成员book4成员变量初始化
* static修饰的funStatic方法
* ***************
* book1成员变量初始化
* book3成员变量初始化
* p1初始化
*///~
}

在上面的例子中我们可以发现两个有意思的地方，第一个是当我们没有创建对象，而是通过类去调用类方法时，尽管该方法没有使用到任何的类成员，类成员还是在方法调用之前就初始化了，这说明，当我们第一次去使用一个类时，就会触发该类的成员初始化。第二个是当我们使用了类方法，完成类的成员的初始化后，再new该类的对象时，static修饰的类成员没有再次初始化，这说明，static修饰的类成员，在程序运行过程中，只需要初始化一次即可，不会进行多次的初始化。
static的第四种用法：静态导包
import static pakage_name.*;
不同于非static导入，采用static导入包后，在不与当前类的方法名冲突的情况下，无需使用“类名.方法名”的方法去调用类方法了，直接可以采用"方法名"去调用类方法，就好像是该类自己的方法一样使用即可。
static是java中非常重要的一个关键字，而且它的用法也很丰富，主要有四种用法：
用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；
用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；
静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；
静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。

当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰，final类中的所有成员方法都会被隐式地指定为final方法
当用final修饰一个方法时，方法锁定，以防任何继承类修改它的含义
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
用于定义建立实例及引用实例，判断实例的关键字：
new :新建
this: 当前
super: 超类，父类
instanceof: 是否是后面类的实例
用于异常处理的关键字：
try: 尝试
catch: 捕获
finally: 不管有没有异常，都会运行
throw: 抛出一个异常
throws: 后面有s的，都是对类声明的。
用于包的关键字：
package:打包成文件夹
import:导入
export: 导出
其他：
native:本地的
transient: 暂时的，临时的
assert:断言

6、标识符

标识符：26个英文字符，数字（不能以数字开头），*和$（只有这两个），严格区分大小写，windows文件夹的命名不区分大小写
命名规范：
包名多单词组成时所有字母都小写，包的命名规则：将公司域名反转作为包名。比如www.baidu.com 对于包名：每个字母都需要小写。比如：com.baidu.test;该包下的Test类的全名是：com.baidu.Test.java 。并且用.隔开，比如aaa.bbb.ccc：代表层次结构.
类名：多单词组成时，每个单词的首字母大写
变量名和函数名：第一个单词小写，以后每个单词首字母大写：convertStringToInt(convertString2Int)
常量：所有常量都大写：final string PI = 3.14

7、注释

注释：
单行：//
多行：/* …/
文档注释：/** …/:文档注释的文字依然可以被解释。生成一套以网页文件形式体现在该程序的说明文档。先将思想整理出来，再用代码去实现。

8、进制的转换：

10进制转8进制，除以8就可以了。0表示正数，1表示负数-128到+127。负数在计算机中的表现形式是正数形式取反加一（补码），0为8为全为0，-128为符号位为1，其余位全为0。
自动类型转化（隐式转换）：升格。当有不同的数据类型同时存在时，自动向高的转移。 比如当short,char，参与运算时，会自动转换为int类型
强制转换（显式转换）：降格：（数据类型）变量
16、字符串可以用“+”操作，把两个连起来，并且可以把非字符串转换为字符串
17、小数默认是double型，要想改成float型，后面加个f，比如，4.0f
18、单个&和单个|，两侧都要参与运算，双&&和双||，只看一侧，一侧成立，另外一侧就不参与运算。所以双与和双或存在短路的可能。单&和单|，用于位运算，双&&和双||，用于bool值间的运算
19、>>>，无符号右移，<<:左移，等于乘以2，>>:右移，等于除以2

第二章 数组

1、数组既能存储原始数据类型，又能存储对象。其中数组的成员变量length，用来表示数组的长度。
2、声明和初始化方法:

	int[] a = new int[10];
a = {1,2,3,4};	//后面为0,数组名和C语言中一样，存放的是a[0]的地址

public class ArryDemo{
public static void main(String[] args){
int[] a =new int[4];
for (int i = 0;i<4;i++){
a[i]=i;
}
System.out.println("a:" + a[3]);
}
}

3、数组的常用操作

3.1 .length：获得数组的长度
3.2 Arrays.fill：将一个数组或者数组指定元素用固定值填充
import java.util.Arrays
Arrays.fill(数组名，开始下标，结束下标，值)（不包含结束下标）
3.3 System.arraycopy(数组a,开始复制下标，复制到数组b，开始复制下标，复制长度)
3.4 Arrays.equals(数组1，数组2)
3.5 Arrays.sort(数组)或Arrays.sort(数组，开始，结束下标)，是升序排列
3.6 Arrays.binarySearch(数组，指定元素)或binarySearch(数组，开始位置，结束位置，指定元素)，在数组中搜索指定元素，返回的是第一次该元素的下标
3.7 Arrays.toString(数组类型 数组名称) 把数据类型转化为字符串类型
3.8 创建一个二维数组,行和列分别为3,4
int[][] a = new int[3][4];

第三章 字符串处理

4.1

java提供了Java.lang.String类以及StringBuffer类来对字符串进行操作，char 对应的类为Character类。其中，Character中含有多个对字符进行操作的函数。

4.2 字符串

字符串的两种最基本的存储方式是顺序存储方式和链接存储方式。

	String stuName = new String(“Ann”);
或String stuName = “Ann”;
或 String stuName = “ ”;
stuName = “Ann”;

4.2.2 字符串的基本操作
获取字符串长度：.length

	String stuName = “ Ann”;
System.out.println(stuName.length);

字符串连接
str1.concat(str2)

public class StringDemo{
public static void main(String args []) {
String str1 = "Hello";
String str2 = "World";
String str3 = str1.concat(str2);
System.out.println(str3);
}
}

注：连接字符串还可以用“+”；从左到右进行运算，Java会根据“+”号两边的操作数类型来决定是进行算术运算还是字符串连接的运算。

public static void main(String args []) {
System.out.println("price" + 10+2.5);
System.out.println(10+2.5+"price");
}

字符串比较：str1.equals(str2); //比较两个字符串是否相等，相同的字母，大小写不同，也是不同的。而str1.equalsIgnoreCase(str2)，比较两个字符串，并且忽视大小写。
比较字符串不能用等于符号， 因为使用 “==”判断对象时，是判断是否为同一个对象。如果内容相同，但是不是同一个对象返回False
字符串截取： str.substring(int begin,int end)
字符串查找：str.indexOf(substr, fromIndex)
字符串替换：用一个新字符去替换字符串中指定的所有字符
str.replace(char oldchar,char newchar)
字符串转换为字符数组str.toCharArray()，字符数组变为字符串，用的是把字符数组传入字符串的构造函数中，自动转换。

4.3 StringBuffer类

StringBuffer类所产生的对象默认有16个字符的长度，内容和长度都可以改变，如果附加的字符超出可容纳的长度，则StringBuffer对象会自动增加长度以容纳被附加的字符。所有在字符串经常改变的情况下使用StringBuffer类型，会让程序的运行效率提高。
StringBuffer对象上有**append()和insert()，delete()，replace()，reverse()**方法，它们有多种重载形式。
Capacity()返回的是当前数据容量和缓冲区容量的和。

第五章 输入语句

java中主要按照流(stream)的模式来实现。其中数据的流向是按照计算机的方向确定的，流入计算机的数据流叫做输入流(inputStream)，由计算机发出的数据流叫做输出流(outputStream)。
对数据流的主要操作都封装在java.io包中，通过java.io包中的类可以实现计算机对数据的输入、输出操作

5.1 用Scanner类

(1)使用java.util包。 import java.util.*;
(2)构造Scanner类对象，它附属于标准输入流System.in。 Scanner s = new Scanner(System.in);
(3)常用的next()方法系列：
nextInt():输入整数
nextLine():输入字符串
nextDouble():输入双精度数
next():输入字符串（以空格作为分隔符）。

import java.util.*;
public class InputDemo {
public static void main(String[] args){
Scanner s = new Scanner(System.in);
System.out.print("输入你的姓名：");
String name = s.nextLine();
System.out.println("姓名：" + name );
s.close();
//若没有关闭Scanner对象将会出现警告

}
}

5.2 使用java.io.BufferedReader和java.io.InputStreamReader：

(1)使用java.io包。 import java.io.*;
(2)构造 BufferedReader类对象，它附属于标准输入流System.in。
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//使用read()和readLine()时，要捕获异常值

public class InputDemo{
public static void main(String[] args) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while(true){
try {
str = br.readLine();
}catch(IOException e){
e.printStackTrace();
}
if(str.equals("END"))break;
System.out.print(str);
}
}
}

第六章 面对对象

6.1 接口

在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。接口中可以声明属性、方法、事件、和类型，但不能声明变量。类比于电脑的USB接口。

interface interfaceDemo{
}

6.2 类的声明结构:

一个类只继承自一个父类，该类实现的接口列表，用逗号分隔开，一个类可以实现多个接口。

public class CarDemo[extend 父类名称][implements 接口名称]{
…
}

6.3 方法的重载：

java支持“重载”方法，并且java能够根据不同的“方法签名”来区分重载的方法，这意味着，在同一类中，可以拥有名称相同但是参数列表不同的方法。比如

pulib class ChongZaiDemo{
…
public void show(String s){
…}
public void show(int t){
…}
}

6.4 抽象类和抽象方法

抽象类用来提供更高级烦人类型抽象，类是有层次关系的，子类总是比父类更具体，将类层次中共有的特性抽取出来，创建包含这些共有特性的抽象类，并由抽象类派生出更加具体的子类。抽象类中可以含有非抽象类。但是抽象类不能被实例化，不能使用new运算符创建类的实例对象，但是抽象类可以派生子类。派生子类时，子类要提供父类中所有抽象方法的实现，如果没有，子类也为抽象类，要用abstract修饰，作为抽象类。抽象类中定义抽象方法，留给子类去实现，子类实现的方式可以不同。

6.4.1 声明抽象类

用关键字abstract声明抽象类。

abstract class Animal{
//声明被所有子类所共享的成员变量
String name;
void sleep() {
pass;
}
//声明抽象方法，由各个子类去实现
abstract void run();
abstract void eat();
}
class dog extends Animal{
void run() {
pass;
}
void eat() {
pass;
}
}

抽象类也可以有静态字段和静态方法（用static修饰），但是static和abstract不能一起使用。

6.4.2 抽象类和接口的对比

接口可以被任何类实现，并且所有方法都隐含抽象的，而抽象类经常被用于子类化，并共享部分实现，在一个单独的抽象类中，提供大部分子类的共同点，即但是还是有一些不同点，抽象方法只声明不实现，即抽象方法，留给不同的子类根据自己的要求去具体实现。如果一个抽象类中包含抽象方法的声明，那么应该讲其声明为一个端口。

6.5 嵌套类

在java中允许在一个类（class A）中定义另外一个类（class B），这样class B被称为嵌套类，class A称为外部类。class B中可以使用class A 中的私有变量，另外，B对外部是隐藏的。
B内部类中不能定义任何静态成员。内部类的实例对象存在于外部的实例对象，并可以直接访问包围它的实例的方法的实例和字段。要实例化一个内部类，必须首先实例化其外部类。

OuterClass outerObject = new OuterClass();
OuterClass.InnerClass innerObject = outerObject..new. InnterClass();

最后

以上就是自然战斗机为你收集整理的java学习笔记的全部内容，希望文章能够帮你解决java学习笔记所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。