java笔记

java面向过程

1.数据类型
1.1基本数据类型
                            默认值		字节数
整数:      byte     8        0			1
          short    16        0			2
           int     32        0			4
          long     64        0l			8
 实型:      float   32        0.0f		4
            double  64       0.00		8
 字符型:     char    16        0		1
( 转义字符省略)
 布尔型:     boolean  true        false
 
 1.2引用数据类型
	除了基本类型之外的全是引用类型

 为什么学习数据类型?
 计算机他自己对于超出范围的数据没有处理能力.

1.3运算符
 (1).双目运算符 :+ - * /
 	对象:针对整数和实型
 	注意：
 	 例1：
 	 int a=2147483647*2;//结果a=-2
 	 long a=2147483647*2;//结果a=-2
 	 long a=2147483647*2L;//结果a=4294967294
 	 结论常整数相乘 结果是int类型，需要类型强转。
 	 例2：
 	 整数与整数相除，精度损失。3/2=1；
(2)单目运算符++ -- + -
 	对象:针对整数和实型
(3)赋值运算符：=

重点:

强制类型转换
变量名 =(类型名) 表达式;

类型自动转换


(4).关系表达式
 >   >=   <   <=   ==  !=
instanceof ( 用于判断前者是否为后者的实例 )

boolean is= 对象名 instanceof 类名;
真 返真 假 返假
 
(5).逻辑表达式
! && || ^(异或)

(6).位运算符表达式
按位取反: ~
按位与 :　＆
按位或　：｜
按位异或：＾
有符号左移：＜＜
有符号右移：＞＞
无符号左移：＜＜＜
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

操作符	描述	例子
＆	    如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100

|	    如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101

^	    如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001

〜	    按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011

<< 	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000

>> 	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111

>>> 	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

(7).运算符优先级
   １　（）［］　．　new
  ２　～　！　++　--　+　-                    自右向左
   ３　* / %
   4 + -
   5 << >> <<<
   6 > >= < <=  instanceof
   7 == !=
   8 &
   9 ^
   10 |
   11 &&
   12 ||
   13 ?:                                     自右向左
   14 = += -= += %= /= <<= >>= <<<= ^= \= &= 自右向左


3.程序语句
控制语句与C++一致.

4.函数
返回值 函数名（形参列表）      
{
	函数体

}                                                  

重点：
参数传递
（1）基本类型参数
	值传递
（2）引用类型参数
	地址传递


 
   
}

java面向对象

下面展示一些 内联代码片。

类入门
1.package的相关使用
文件夹层次结构，其实就是文件夹，每有一个"."就是跳入下一个文件夹，这种包其实就是为了方便管理类.
2.import语句导包
格式: import 包名.类名;
注意:(1).import语句要位于package语句之后
(2).类名可以用"*"代替, 指导入包内所有类. 但import java.awt.*; 不能导入java.awt.event;包中的类.
(3).java源程序默认引入java.lang.*; 因此该包所有类均可使用.
总结: 类似#include <>, 同样是导入工具包, 只是形式不同.
(4). 导包其实是根据"classpath"(也就是常说的环境变量配置的原因)路径找jar包。

3.类的定义
3.1定义形式:
[public] [abstract|final] class 类名[extends 父类名][implements 接口列表]  //类首部
{
定义成员变量;//用于描述静态属性
定义构造方法;//一般对于成员变量初始化
定义成员方法;//用于描述动态行为
}

说明:
(1). []表示可选, | 表示二选一
(2). public是访问控制修饰符, 表示该类为公共类, 即所有类均可访问它.
 若省略public表示其访问级别为默认级别, 此时只有同包的类可以访问它,此时只用同包的类可以访问它.
 一个源程序文件可以定义多个类, 但是只能有一个public的类,而且文件名与类名要一致.
 若希望一个包中的所有类均为public类型, 应在不同的.java文件中定义,
 当然此时每个文件开始都要使用package语句声名它们处在同一个包.
(3). 类内部成员定义一般都要加上访问限制修饰符。
3.2对象创建和对象的引用
	创建对象: 类名 对象名称 = new 类名(参数列表);
//与C++基本一致.
3.3成员变量
定义形式:
	[访问控制符] [static] [final] 类型名 变量名列表;
(1). final常量修饰符, 定义时初始化.//初始化在类定义时或者构造函数初始化
(2). static静态成员, 静态成员属于所有对象共有, 基本与C++一致, 但也有不同之处.
 推荐访问方式, 类名.静态成员;
 初始化在类定义时


附访问控制符
--------------------------------------------------------------------------------------------
  |    同类中    |   同包中    |    不同包子类中    |    不同包非子类中
--------------------------------------------------------------------------------------------
private |      /      |      X     |        X         |        X
--------------------------------------------------------------------------------------------
默认    |      /      |      /     |        X         |        X
--------------------------------------------------------------------------------------------
protect |      /      |      /     |        /         |        X
--------------------------------------------------------------------------------------------
public  |      /      |      /     |        /         |        /
--------------------------------------------------------------------------------------------
此外强调, 在一个类中调用另外一个类, 这个类必须是public类型, 否则不行.

4.构造方法
(1).基本与C++一致.
但是   他的构造函数和普通函数一样, 必须要有访问控制符public来修饰, 这样才能为对象创建所调用，必须要有空参构造（默认构造）.

5.成员函数
定义格式:
[修饰符]返回值类型 函数名( 形参列表 ) [throws 异常列表]
{
函数定义;
}
(1).修饰符可以是 访问控制符   static   final   abstract    native   synchronized 等作为方法的修饰符
(2).static  修饰  与C++一致, 静态函数方法.
(3).final为最终方法, 不能被重载.
(4).abstract 是抽象方法.与static不能共存.
(5)synchronized是多线程控制的.

此外, 方法名称数据访问和修改, 固定格式, get   set   , 驼峰式.

以及, 方法重载, 与C++一致, 参数列表个数或类型不一致, 则为方法重载, 注意, 形参列表一致, 而返回值不同, 不是方法重载.
6.继承
6.1继承的概念
java只支持单继承
 
6.2继承的实现
基本格式:
class B extends A
 
{
	...
}
说明:
(1).未使用extends指定父类,默认继承java.lang.Object
(2).子类继承父类的private时,只是访问受限.
(3).构造方法并不属于父类的方法,不能被继承.
(4).构造函数一定要有一个无参构造.

6.3方法重写和属性隐藏
说明:
(1).访问控制符控制访问属性,根据需要使用.
(2).重写时不能减小函数访问范围.
(3).final所修饰的函数不能被重写.
(3).注意区别方法重载和方法重写的区别,方法重写是与父类参数返回值等等参数均一致多情况下重写.*而方法重载是形参列表的不同.
(4).在子类可以使用super.方法名(形参列表)调用父类方法.
(6).父类和子类里面可以建立相同名字的函数,或者变量,但是这样会让父类的函数或变量隐藏起来,当然也是可以调用的,
只要用super关键字.
 
6.4关键字super和this
说明:
(1).this类比C++.(自己的地址)
(2).super,父类的地址.
主要是构造函数用,以及调用父类成员.

7.抽象类
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
 
格式:
public abstract class类名
{
构造方法;
成员变量;
成员函数;
}
注:(1).基本与普通类一致,但是构造方法可使用,不能实例化.
(2).被继承后所有的抽象函数必须实例化(重写).
8.继承性和多态性
继承性:
通过继承的方式让代码重用.
多态性:
不同类的对象可以对同一个消息做出反应,体现在java就是不同类对象的函数调用同名方法,结果不同.
 
9.接口
9.1接口的定义
格式:
public [abstract] interface接口名 [extends父类接口列表]
{
...
}
说明:
(1).访问控制符只能是public或者省略.
(2).abstract可以省略,extends表示接口可以多继承.
(3).接口中的变量默认以public static final修饰,可不写,意味着接口中只有常量.
(4).接口中函数默认一以public abstract修饰,但从javase8允许接口中定义以default修饰的非抽象方法和以static修饰静态方法.
(5).接口中无构造方法.
(6).接口也可以用instanceof 运算符判断该类是否实现了该接口。
9.2接口和多态
接口不能实例化,但是可以定义接口引用.
接口名  接口引用名;
接口引用可以指向任意一个实现它的类的对象,类似父类引用指向不同子类对象.

(子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，定义一个父类类型的引用指向*一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。所以，父类类型的引用可以调用父类中定义的所有属性
和方法，而对于子类中定义而父类中没有的方法，父类引用是无法调用的；
那什么是动态链接呢？当父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。)

10.嵌套类

类里面又是另一番天地,想怎么定义就怎么定义呗.
注意：由于java的垃圾回收机制，导致匿名类的出现，也就是申请内存不用管释放。 
11.枚举

 
 
番外篇
 
static 变量和方法
 
. 静态方法如何调用？
java 用“ . ”运算符
C++ 用“：：”或者 “  .  ”
. 静态方法不能调用普通成员方法？
在静态方法是在类加载的时候就已经编译了，而实例方法必须有实例的清空下才能使用。
 
final  
能用一定用上， 防止别人篡改数据， 或者别的。很有用的。
C++用const

java高级部分

1.Object类
	Class Object是类Object结构的根。 每个班都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。
	1.1构造方法
	public Object()
	
	1.2具体方法
	public final class<?> getClass()；
	返回此Object的运行时类。
	public String toString()
	对象的字符串表示形式。
	public int hashCode()
	返回对象的哈希码值。 支持这种方法是为了散列表，如HashMap提供的那样 。
	public boolean equals(Object obj)
	指示一些其他对象是否等于此。（根据hashCode（））
	getClass().getName() + '@' + Integer.toHexString(hashCode())
	

------------------------------------------------------------------------------

	protected void finalize()
                 throws Throwable
    当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。
	void notify()
	唤醒正在等待对象监视器的单个线程。
	void notifyAll()
	唤醒正在等待对象监视器的所有线程。
	void wait()
	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 		notifyAll()方法。
	void wait(long timeout)
	导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 		notifyAll()方法，或者指定的时间已过。
	void wait(long timeout, int nanos)
	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。



2.String类
成员变量：

静态成员变量：

构造函数：

功能函数：

静态函数：

小技巧：
1.解决字符乱码问题
public byte[] getByes(String charsetName);//获取指定字符串给定编码格式二进制形式
public  String(byte bytes[], String charsetNmae);//按照charsetName编码格式解读bytes字符串二进制
这两个函数相互配合，循环测试。
3.
	
 	

我的一些疑惑

1.函数参数传递方式？
基本类型 值传递
引用类型 地址传递

2.修饰符位置？
可以任意。

3.创建类时，什么情况下加修饰符（public）？
文章内部有答案。

我的一些建议

1.类不应该被子类化，除非程序员打算修改或增强类的基本行为。
2.