JAVA学习笔记

类所描述的是对象知道什么和执行什么

对象是由类所创造（规定）的，类是对象的蓝图

实例是特定类的每个对象

对象有状态和行为两种属性，分别由实例变量和方法来表示

面向对象的重点：行为会依据状态来决定，也就是方法会使用到实例变量的值

方法会运用形参，调用的一方会传入实参

传入和传出方法的值类型可以是隐含的放大或是明确的缩小

封装的原则：将实例变量标为私有（private）,并提供共有的getter与setter来控制存取动作

实例变量与局部变量的差别：实例变量是声明在类中而不是方法中，局部变量声明在方法中，局部变量在使用前必须初始化。

==用来比较两个primitive主数据类型是否相等，或者判断两个引用是否引用同一个对象；equals()用来判断两个对象是否一模一样

面向对象专注于程序中出现的事物而非过程

面向对象是指以组建化的形式进行代码设计，最大的优点是可以复用

OOA OOD OOP 面相对象分析 设计 编程

类是共性的集合，对象是个性的产物

简单java类不包括过于复杂的程序逻辑：
类名称必须有意义
类属性必须封装，提供setter,getter
类中可提供多个构造方法，但必须保留一个无参构造方法(若没有提供，系统会自动生成一个无参构造方法)
类中不允许出现任何输出语句，所有信息输出必须交给被调用处输出
类之中需提供有一个取得对象完整信息的方法

java两种类型：引用数据类型，基本数据类型，最大的不同在于前者需要内存的开辟和使用，new的功能就是开辟堆内存(只要是引用类型，就要有new)

不同的名字指向同一个实体，这就是引用的精髓

所有在类中定义的属性都要求用private声明
对于标准开发，setter,getter只是简单的设置和取得数据，数据验证在辅助代码中实现

所有构造方法都在对象使用关键字new实例化时使用
构造方法是在实例化新对象的时候只调用一次，普通方法是在实例化对象之后可以调用任意次。

若类中已经定义有参构造方法，则自动生成的无参构造将会失效，需重新编写无参构造

构造方法的核心作用是在对象实例化的时候设置属性的初始化内容

构造方法重载的时候需按照参数个数升序或降序编写，只需考虑参数的类型和个数

构造方法的名称与类名称相同，无返回值声明(void都没有)

数组属于引用数据类型，也需声明和开辟
与引用对象的区别是堆内存保存对象的属性，数组堆内存保存的是一组信息

主方法是作为程序的起点，要尽量精简

String类的“＝＝”比较的是类所在堆内存地址的数值，equals(String类的方法)才可比较内容

使用构造方法定义的String类对象，其内容不会自动保存在对象池之中(直接赋值定义的可以)，但可采用intern()方法手工入池

String一旦声明则其内容无法改变，字符串所谓内容的改变实际上是利用了引用关系的变化而实现的，但是每一次引用关系的变化都会产生垃圾

如果方法返回值为boolean布尔值，习惯将方法名命名为isXxx()

只有String类才具有大小的判断关系

使用this()调用构造方法形式的代码只能放在构造方法的首行，进行构造方法的互相调用时，一定要保留调用的出口

对象比较一定是某一个类自己定义的方法
比较时一定要判断是否为null,地址是否相同，属性是否相同

static属性与非static属性区别在于保存的内存区域的不同(static保存在全局数据区)，最大在于区别没有实例化对象时，static可以被类所调用

static方法只能调用static属性和static方法，也不能使用this关键字(this的使用需要对象实例化，而static无需实例化对象就可使用)；而非static方法能访问static方法和属性，不受限制

如果一个类中只有方法没有属性，那么可以考虑将所有的方法定义为static，那么在调用方法时就无需实例化对象了

主方法的static证明此方法是由类名称直接调用，如：java testdemo(运行语句)

主方法的void表示该方法为执行起点，不能回头

main是规定好的关键字不能修改

内部类最大的优点：是可以访问外部类的私有操作方法，外部类也可以访问内部类的私有属性和方法

内部类的实例化方法：外部类.内部类 对象 ＝ new 外部类（）.new 内部类（）； 即先要保证有外部类才能产生内部类

若看到类.类.类(没有实例化之前的类)的实例化方法要知道是因为内部类用static定义了

内部类用到最多的是在方法中定义

链表中link类主要功能是控制node类对象的产生和根结点；node类主要负责数据的保存以及引用关系的分配

链表就是动态对象数组

java不允许多继承，但c++允许。可以使用多层继承来实现java的多继承

子类只能间接的访问父类中的private属性，不能在子类对其进行直接操作

在实例化子类对象前，会自动实例化父类对象(默认无参构造)，没有无参构造就要在子类中添加super(参数)方法，一定要放在子类构造的首行(无参super可以不写)

而this()也要放在构造方法的首行，这就矛盾了，所以this()跟super()不能同时出现

覆写的方法不能够拥有比父类更严格的访问控制权限。访问控制权限：public＞default(缺省，就是在声明方法时不添加public或private)＞private，%99的情况下只要是方法都用public，所以覆写的方法也大多是public(不能严格于父类)

但如果父类的方法使用了private声明，那就意味着该方法对子类不可见，所以子类无法覆写，这时候子类相当于自己定义了一个新的方法

默认情况下子类所能够调用的一定是被覆写过的方法，若想调用父类中未被覆写的方法，那么可以使用“super.方法（）”

this.方法（）会先查找子类中是否有此方法，若没有则会去父类中的同名方法。

面试题：请解释重载(overloading)与覆写(override)的区别
1，覆写发生在两类继承时，重载发生在一个类中
2，覆写有访问权限的限制，重载没有
3，覆写要求返回值，名称，参数类型及个数都要相同，而重载都可以不同
在使用overloading的时候返回值可以不同但尽量相同。

使用final定义的类不能有子类(太监类)
使用final定义的方法不能被子类所覆写

使用final定义的变量就成为了常量，常量无法被修改，常量必须在定义的时候就设置好内容，所有常量都必须要用大写字母书写

变量命名方式同方法，第一个单词小写，第二个单词首字母大写

public static final 声明的就是全局常量

对象多态性即子类和父类之间的转换，分为
向上转型(自动)：(实现参数的统一)
父类 父类对象 ＝ 子类实例
向下转型（强制）： (父类可以使用子类的特殊方法)
子类 子类对象 ＝ （子类）父类实例

%80的情况下都只会使用向上转型
%5的情况下使用向下转型，调用子类的特殊方法
%15的情况下是不转型
尽量别转型

向下转型之前一定要先向上转型使父类知道哦这是我儿子，从而能顺利转型，否则会报错

抽象方法没有｛｝，抽象类和抽象方法都要用abstract定义

抽象类只是比普通类多了个抽象方法，而且无法实例化

抽象类必须有子类，子类(当他不是抽象类时)必须覆写抽象类的所有抽象方法
抽象类的对象实例化需要依靠子类完成，采用向上转型方法实现

虽然一个普通类可以任意继承(除final类)，但是从开发的角度讲，普通类最好只去继承抽象类

虽然无法实例化但是抽象类也有构造方法，目的是初始化抽象类中的属性

外部抽象类不允许使用static声明(why?)，外部类的内部抽象类可以使用static声明。
(static声明的内部类相当于外部类，只不过继承时使用外部类.内部类的形式表示类名称)

任何情况下只要类中有static方法都可以在未实例化的情况下直接调用该方法，抽象类也一样

接口是一种特殊的抽象类，只有抽象方法和全局常量(没有构造方法)，使用interface定义
interface A｛｝

一个子类可以继承多个接口（利用implements关键字），一个接口必须有子类继承，若该子类非抽象类，则必须覆写接口中所有抽象方法

接口可以通过子类对象的向上转型进行实例化操作

若一子类又继承抽象类，也继承接口，那么先extents,后implements

接口中方法的访问权限只能是public，故public abstract 可以省略（但建议保留public，以免子类覆写时，权限出错）；且常量前的public static final也可省略

一个接口可以使用extents继承多个接口，但是接口不能继承抽象类

接口内部可以定义内部普通类，内部抽象类（abstract不能省！），内部接口等不受限制

接口的三大核心作用，
定义不同层之间的操作标准
表示一种操作能力
表示将服务器端的远程方法视图暴露给客户端

定义标准（如usb标准）也就是定义一个接口，标准可以连接不同层次的操作类

工厂模式和代理模式代码要背！

在进行某些公共操作时一定要定义接口
自己写的接口不要用关键字new直接实例化接口子类，用工厂类完成

object类是所有类的父类
在不确定参数类型的时候使用object类型是最好的选择

严格来讲，所有类都应该覆写objact类的如下三个方法：取得对象信息（String toString()），对象比较(boolean equals())，取得对象HASH码（int hashCode()）

toString为了适应所有对象的输出，默认只输出对象的编码，即堆地址空间，如果有实际需要，也可以覆写此方法

代码模型：
简单java类
类的转换
对象比较
接口应用

匿名内部类的存在是为了简化代码，真正开发中一个文件中只应该有一个类

直接将接口子类｛｝中的代码复制进主方法中的方法括号里即可实现匿名内部类，使用匿名内部类必须要有接口的定义

如果匿名内部类定义在了方法里面，方法的参数或变量必须加上final关键字（jdk1.8之后就不用
）

基本数据类型的装箱与拆箱是为了把不是对象的数据包装成对象，在使用基本数据类型进行运算时再拆箱进行运算

java提供了相应的包装类：byte(Byte), short(Short), int(Integer), long(Long), float(Float), double(Double), char(Character), boolean(Boolean)

以上有分为两种类型：
对象型包装类（object直接子类）：Character, Boolean
数值型包装类（Number直接子类）：…

Number是一个抽象类，里面定义了六个操作方法bytValue(), intValue(),…

jdk1.5之后java提供了自动装箱和拆箱，这使得包装类也能直接进行运算和赋值

一般开发，包装类都是直接赋值，但是要注意进行内容比较时一定要用equals!

使用包装类最多的情况实际上是因为他提供的数据类型转换功能上，如可将String型数据转换为基本类型的方法，值得注意的是Character并不存在将字符串转换为字符的方法因为String类有charAt()这个方法根据索引取字符

数值型包装类进行这样的转换时，被转换的字符串一定只能由数字组成

在Boolean进行字符串转换时，当字符串中的字母不’‘true’‘或者’‘false’‘时当做’‘false’'来进行转换

当然也可以反过来转换：
任何基本数据类型与字符串进行+操作后都会转换为字符串
利用valueOf()转换不会产生垃圾

包是程序的一个目录，利用包可以实现根据要求将代码保存在不同的目录之下（规避不同开发者使用相同的类名称，不同目录就没关系）

用package在java文件首行定义

eg: package cn.mldn.demo, . 表示子目录，这些目录应该用语句javac -d . xxx.java自动生成而不能手工

javac -d.*.java 会自动按顺序编译关联文件

-d代表生成目录
.表示在当前所在路径下生成

开发中类都要定义在包当中，完整的类名称就是 包.路径.类
不同的包互相访问使用import语句
import.包.类

import.包.*可以自动导入程序里所需要的类，无需重复导入相同的包

public class 与 class的区别：
public class 类的名称必须与文件名一致;
一个文件中只能有一个public class声明；
如果一个类要被另外的包所调用，必须加上public

两个包中有同名的java文件被同时调用就需要在运用时加上包名称

常用包：
java.lang: 包含String, Object, Integer等类
java.lang.reflect: 反射开发包（java精髓）
java.util: java的工具包，提供了大量的工具类如链表
java.util.regex: 正则工具包
java.text: 国际化处理包
java.io: 输入输出处理以及文件操作
java.net: 网络编程开发包
java.sql: 数据库程序开发包

jar命令针对编译后的*.class文件进行压缩并且压缩的单位都是以包为主

jar命令之后必须配置CLASSPATH才可以加载

构造方法私有化：即在构造方法前加上private，无法在外部通过new来实例化对象，只能在内部声明static 类 类名称 ＝ new 类()，而后在外部采用类.对象名的方法调用该对象（这样可以不用先实例化该类）

但是作为类的一个属性，static 类 类名称 ＝ new 类() 还应进行封装加上private，此时就需要增加static getter方法来从外部获得该属性

构造方法私有化的目的是为了控制实例化对象的产生个数，所以要先锁定类中构造方法，这样产生的对象就在全局变量区，无论调用多少次getter实例化对象都只有一个，这样的设计叫做单例设计Singleton

在构造方法私有化的类中实例化自己时加上final 变量名，这才是单例设计最严谨的模式
记住上述代码

单例设计分为饿汉式和懒汉式，区别在于，饿汉式一开始就在内部实例化了一个对象而不管外部用的着不着；懒汉式则是在第一次被使用时才进行实例化操作

多例设计则是私有化构造方法来产生指定个数的实例化对象

java实现多线程的方法：
继承Thread类
实现Runnable接口
实现Callable接口（不常用）

Thread类只有有一个子类就能实现多线程，所有的多线程除了main()之外还要有自己的一个起点，也就是run()方法，在多线程的每个主题类（Thread的子类）中都应该覆写Thread类中所提供的run()方法，跟main()一样，线程一旦开始就要一直往下执行不能返回内容

直接调用run()并不能启动多线程，而应调用start()方法 why?因为这是jvm在不同系统中都能运行多线程的抽象方法，具体方法调用自操作系统，只有操作系统能够实现系统资源的分配

但是开发中多线程的实现都是采用Runnable接口，此接口为函数接口，只有一个抽象方法run(),但此方法无返回值（所以不能起到函数功能），只是说明该接口只有一个方法

但是无论哪种情况下都应该借助Thread类的start()方法，而Thread有个单参构造Thread(Runnable target)提供故此实现多线程

面试题：多线程两种实现方式的区别
Thread类是Runnable接口的子类，接口比起类解决了单线程的限制
接口比类能更好的描述出数据共享的概念

Thread类和Runnable实现方式代码记住！

System.out.println(对象名称)输出对象堆内存空间地址

编写标识符时尽量不要使用数字如i1,i2，开头也不能是数字； java中标识符区分大小写；＄有特殊意义，不去使用

java中整数的默认保存类型为int,默认的小数默认保存类型为double(范围最大)

double有效数字为16位，占8个字节；float有效数字为8位，占4个字节

大范围变量与小范围变量的运算结果类型为大范围变量。如：int变量±long型常量＝long型数据

string属于引用数据类型(属于一个类，java里只要是类，单词的首字母都是大写)，但是其用法较为特殊

制表符(\t)表示按一下tab或是按八下空格

switch支持字符串的直接判断如判断str是否为"hello"从而进行分枝判断

for循环最大的特点是已经明确知道了循环次数

return可以返回值，也可结束方法调用(其后的代码不予执行)

方法递归调用必须满足的条件：
必须有结束条件
每次调用的时候都需要改变传递的参数

java采取的是16进制的unicode编码，为每个字符制定了一个唯一的数值，这样就可以在任何语言、平台、程序上安心运行

面向对象三大特征：封装性，继承性，多态性
封装：保护代码内部的定义结构安全性
继承：在已有的程序结构上继续扩充新的功能
多态性：在某个概念范围内的满足

封装一是为了保证外界不能随意更改内部的属性值，也不能任意调动其内部的功能方法；二是为封装在一个整体内的变量及方法规定了不同级别的"可见性"或访问权限

java通过接口(interface)的方式来弥补不支持多继承而带来的子类不能享用多个父类的成员的遗憾

多态性主要体现在方法重载和对象多态上
方法重载(略)
对象多态是指子类对象与父类对象进行相互的转换，而且根据其使用的子类的不同，完成的功能也不同

堆内存保存的是对象的属性内容(实例变量)，通过new来开辟，若没有遥控器(堆内存指向)，将被扫入垃圾堆(清理内存)
栈内存保存的是一块堆内存的地址(相当于指针)

构造方法本身是一种特殊的方法，只会在声明新对象(对象实例化)的时候调用，原则：方法名与类名称相同，没有返回值类型声明，同时构造方法也可以进行方法重载

匿名对象就是没有遥控器指向(没有栈内存指向堆内存空间)的对象，如
new book(“java开发”，69.8).getinfo();

数组动态初始化就是只声明数组的大小，而静态初始化就是声明数组所有具体元素

字符串常量是string类的匿名对象，如可直接
system.out.println(“hellow”.equals(str));其中hellow是作为类似阿拉伯数字1一样的常量存在

字符串一旦定义则不可改变，即堆内存中的字符串常量要么被引用，要么被回收，是无法更改其内容的

正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

this可以表示本类属性、表示本类