类
对象：一个类具体的实例化
实例：值的就是一个对象的实体
引用：引用 就是对象或者实例之间的调用了 ，对象的别名，使用该别名可以存放该对象。编译器不会为引用分配空间，新对象与原对象共用一个存储地址空间；
引用的生命周期是它所引用对象的生命周期，函数里面返回一个局部对象的引用是很危险的
在java实现某个功能的时候，会将类实例化成对象，然后jvm再对实例化后的对象进行操作，例化后的对象可以赋值，也可以引用。
赋值时，java会开辟一个新的地址用于存放变量，而引用则不开辟地址 ？？
在一个Java文件里，最多只能有一个public外部类(但可以有多个public内部类)，并且java文件的名字和这个public类的名字要一致，否则.java的文件便无法命名
类似于一般程序语言中的函数（function），但在Java中称之为method（方法）。因此C语言里的main()函数（主函数），在Java中则被称为main() method（主方法）。
每一个独立的Java程序一定要有main() method才能运行，因为它是程序开始运行的起点。
打印格式 ： System.out.println("这是数字 "+num); num为变量
数组：
数据类型 数组名[ ] ； // 声明一维数组
数组名 = new 数据类型[个数] ; // 分配内存给数组
int score[] ; // 声明整型数组score
score = new int[10]; // 为整型数组score分配内存空间，其元素个数为10
或者 int score[] = new int[10] ;
int score[][] = new int[4][3] ; // 声明整型二维数组score，同时为其开辟一块内存空间
score.length 值为 10 ; // 数组名.length 取得数组的长度
int day[] = {32,23,45,22,13,45,78,96,43,32}; // 数组声明并赋初值
System.arrayCopy(source,0,dest,0,x)：语句的意思就是：复制源数组从下标0开始的x个元素到目标数组，从目标数组的下标0所对应的位置开始存取
方法：
在static方法内只能访问到static成员变量（包括数据成员和方法成员）
方法的重载：在同一个类中允许同时存在一个以上的同名方法，只要它们的参数个数或类型不同即可
Java面向对象程序设计：
将具有相同属性及相同行为的一组对象称为类
向对象的程序设计有三个主要特征，如下： 封装性 继承性 多态性
封装机制：
把描述对象属性的变量及实现对象功能的方法合在一起，定义为一个程序单位，并保证外界不能任意更改其内部的属性值，也不能任意调动其内部的功能方法。
它的另一个特点是，为封装在一个整体内的变量及方法规定了不同级别的“可见性”或访问权限。
继承：
若一个子类只允许继承一个父类，称为单继承；若允许继承多个父类，称为多继承。目前许多面向对象程序设计语言不支持多继承。
而Java语言通过接口（interface）的方式来弥补由于Java不支持多继承而带来的子类不能享用多个父类的成员的缺憾。
类的多态性：
ava语言中含有方法重载与成员覆盖两种形式的多态
方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同
成员覆盖：子类与父类允许具有相同的变量名称，但数据类型不同，允许具有相同的方法名称，但完成的功能不同。
类（class）和对象（object）
类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的个体，因而也称实例（Instance）
类名中单词的首字母是大写的，这是规定的一种符合标准的写法
创建好了一个Person的类，但是在实际中单单有类是不够的，类提供的只是一个摸板，必须依照它创建出对象之后才可以使用
类名 对象名 = new 类名() ;
Person p ; // 先声明一个Person类的对象p
p = new Person() ; // 用new 关键字实例化Person的对象p
或者：Person p = new Person() ; // 声明Person对象p并直接实例化此对象 对象只有在实例化之后才能被使用，而实例化对象的关键字就是new。
Person p1 = null ; 声明一对象p1，此对象的值为null，表示未实例化
p1 = p ;将p的引用赋给p1
p.name ; // 访问Person类中的name属性
p.talk() ; // 调用Person类中的talk()方法
用private可以将属性封装起来，private声明的属性或方法只能在其类的内部被调用，而不能在类的外部被调用
关于是否采用封装方式并没有一个明确的规定，不过从程序设计角度来说，一般说来设计较好的程序的类中的属性都是需要封装的。
此时，要设置或取得属性值，则只能用setXxx()、getXxx()方法，这是一个明确且标准的规定。
内部类：
1.内部类可声明成public或private。当内部类声明成public或private时，对其访问的限制与成员变量和成员方法完全相同
2.但是外部类是不能直接使用内部类中所声明的属性。而内部类则可以直接访问外部类的属性。
3.用static声明的内部类则变成外部类，但是用static声明的内部类不能访问非static的外部类属性。
4.被public声明的内部类也可以通过创建对象被外部类之外调用，就如使用外部类的方法和变量一样 Outer.Inner inner = outer.new Inner();
5.内部类不仅可以在类中定义，也可以在方法中定义。 在方法中定义的内部类，除了访问外部类的变量外，只能访问方法中的final类型的局部变量，因为用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期
匿名对象：
System.out.println(new Person().talk()); “new Person().talk()” 为匿名对象 new Person()声明的对象并没有赋给任何一个Person类对象的引用，所以此对象只使用了一次，之后就会被Java的垃圾收集器回收
构造方法：
构造方法的基本作用就是为类中的属性初始化的，在新建实例对象时，将需要的参数由构造方法传入，之后再由构造方法为其内部的属性进行初始化。这是在一般开发中经常使用的技巧
特点：1、它具有与类名相同的名称 2、它没有返回值 3.构造方法在实例化对象时，便自动调用执行
public Person(String n,int a)
Person p = new Person("张三",25) ;
如果在执行javac编译java程序的时候，如果在程序中没有明确声明一构造方法的话，系统会自动为类加入一个无参的且什么都不做的构造方法。类似于下面代码：public Person() { }
构造方法的重载： 只要构造方法的参数个数不同，或是类型不同，便可定义多个名称相同的构造方法。这种做法在java中是常见的
构造函数或者说构造方法也可声明为private类型，则此构造方法只能在本类内被调用，构造方法被私有了之后，只能在本类中产生实例化对象
对象的比较
“= =”操作符用于比较两个对象的内存地址值是否相等 if(str1==str2)
equals()方法用于比较两个对象的内容是否一致 str1.equals(str2)
String str1 = new String("java");与 String str2 = "java";
new String(“java”)方式实例化String对象时，实际上是开辟了两个内存空间，所以一般在开发上都采用直接赋值的方式，即：String str1 = "java"
this关键字的使用
this.name和this.age就分别代表类中的name与age属性
如果在程序中想用某一构造方法调用另一构造方法，可以用this来实现
this() ; // 调用本类中无参构造方法
注意 ：使用this调用构造方法必须只能放在其他调用它的构造方法的第一行
static关键字的使用
1.用static来声明静态变量 和静态方法
2.static声明的属性是所有对象共享的，用static方式声明的属性，也可以用类名直接访问Person.city = “美国” 。所以static变量有时候也称为“类变量”
3.既然static类型的变量是所有对象共享的内存空间，并且每个对象产生时都会去调用构造函数，所以可以在构造方法中加入记数操作变量，来记录类有多少个对象产生。
4.static类型的属性不能调用非static类型的属性（包括变量和方法）
非static类型的属性，可以调用静态和非静态的属性。
main()方法
如果一个类要被Java解释器直接装载运行，这个类中必须有main()方法，main()方法访问权限必须是public，因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的
该方法接收一个String类型的数组参数，通过下面的命令可以执行带参数的类 java 类名称参数1 参数2 参数3
静态代码块
一个类可以使用不包含在任何方法体中的静态代码块，
1.当类被载入时，静态代码块被执行，（在执行构造函数之前就会执行）且只会执行一次（多次创建类对象时，也只执行一次），静态代码块经常用来进行类属性的初始化
static
{
。。。。。。
}
对象数组的使用
Person p[] ; // 声明Person类类型的数组变量
p = new Person[3] ; // 用new分配内存空间
或者Person p[] = new Person[3]; // 创建对象数组元素，并分配内存空间
Java注释
基本的两种注释为 ： // 和 /*… */
第三种注释，称为文档注释， 它以“/**”开始，以“*/”结束， 会嵌入到程序中，开发者可以使用javadoc工具将信息取出，然后转换为HTML文件。文档注释提供了编写程序文档的便利方式
javadoc标记
所有的文档标记都以“@”标志开始。在一个文档注释中，也可以使用其它的标准HTML标记
@author 确定类的作者
@exception 确定一个方法引发的异常
类的继承：
1.class 子类 extends 父类 // 用extends关键字实现类的继承
2.在java中只允许单继承，而不允许多重继承，也就是说一个子类只能有一个父类，但是java中却允许多层继承。
3.子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法 。
如果父类中指定了带参数的构造方法，则默认无参构造方法不会再生成，所以实例化子类对象时会出现找不到父类中无参构造方法的问题，这种情况下注意要在父类中添加一个无参的构造方法。
super关键字：
1.super主要的功能是完成子类调用父类中的内容（属性或方法），常用来调用父类带参数的构造方法
2.用super调用父类中的构造方法，只能放在子类构造方法程序中的第一行。
3.super.name = name ; 在这里用super调用父类中的属性name
4.在父类中加入了private关键字修饰的属性，其目的只是相当于对子类隐藏了此属性，子类无法去显式的调用这些属性，但是却可以隐式地去调用
复写：
1.“复写”的概念与“重载”相似，它们均是Java“多态”的技术之一
2.当一个子类继承一父类，而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致时，就称子类中的这个方法复写了父类中的方法。
同理，如果子类中重复定义了父类中已有的属性，则称此子类中的属性复写了父类中的属性
3.子类复写父类中的方法时，被子类复写的方法不能拥有比父类中更严格的访问权限。
4.在子类可以通过super.方法()的方式调用父类中被子类复写的方法。
this：1、表示当前对象 2、调用本类中的方法或属性 3、调用本类中的构造方法时，放在程序首行
super ：1、子类调用父类的方法或属性 2、调用父类中构造方法时，放在程序首行
抽象类：
1.抽象类是专门用来当作父类，有点类似“模版”，其目的是要设计者依据它的格式来修改并创建新的类。但它不能直接创建对象，只能通过抽象类派生出新的类，再由派生的新类来创建对象。
2.抽象类和抽象方法都必须用abstract关键字来修饰
3.抽象类不能被实例化，也就是不能用new关键字去产生对象
4.抽象方法只需声明，而不需实现
5.含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
6.与一般类相同，在抽象类中，也可以拥有构造方法，但是这些构造方法必须在子类中被调用（在抽象类中声明构造方法后，在子类中必须明确调用）。
Object类：
1.Object类它是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类就默认继承Object类
2.Object类的方法中有一个toString()方法。这个toString（）方法需要被object子类复写才能使用。如System.out.println(p); 等价于 System.out.println(p.toString());其中P为Person p = new Person() Person类继承Object
final关键字：
1、 final标记的类不能被继承。
2、 final标记的方法不能被子类复写。
3、 final标记的变量（成员变量或局部变量）即为常量，只能赋值一次。
Interface 接口：
Interface它的结构和抽象类非常相似，也具有数据成员与抽象方法，但它与抽象类又不同：
1、接口里的数据成员必须初始化，且数据成员均为常量。接口不能创建对象，利用接口打造新的类的过程，称之为接口的实现（implementation）。
2、接口里的方法必须全部声明为abstract，也就是说，接口不能像抽象类一样保有一般的方法，而必须全部是“抽象方法”。
3、interface里面的常量和抽象关键字final、abstract可以省掉
4.interface接口是在java中用于实现多继承的一种机制，一个类只可以继承一个父类，但却可以实现多个接口，每一个由接口实现的类必须在类内部复写接口中的抽象方法，且可自由地使用接口中的常量。
5.接口与一般类一样，均可通过扩展的技术来派生出新的接口。原来的接口称为基本接口或父接口，派生出的接口称为派生接口或子接口。并且一个接口可以继承多个接口
interface 接口名称 // 定义抽象类
{
final 数据类型成员名称 = 常量； // 数据成员必须赋初值
abstract 返回值的数据类型方法名称（参数…）；
// 抽象方法，注意在抽象方法里，没有定义方法主体。
}
class 类名称 implements 接口A,接口B // 接口的实现
interface 子接口名称 extends 父接口1，父接口2，… //一个子接口可以继承多个父接口
对象多态性：
向上转型:父类对象通过子类对象去实例化,可以自动完成,但是向上转型会丢失精度
向下转型:父类的对象转换为子类对象，这时则必须要进行强制的类型转换
Person p = new Student() ;
p.fun1() ;实际调用了子类中被复写了的fun1()方法，而不是父类的fun1()方法！
instanceof关键字
作用：instanceof用来判断一个类是否实现了某个接口，也可以用来判断一个实例对象是否属于一个类
操作格式： 对象 instanceof 类(或接口) 返回布尔型的值true或者false
if(p instanceof Student)
object类中的equals方法
会发现在Object类中有一个equals方法，此方法用于比较对象是否相等，而且此方法必须被复写，类似于object类中的toString()方法，也是需要被复写的
接口对象的实例化
接口是无法直接实例化的，因为接口中没有构造方法，但是却可以根据对象多态性的概念，通过接口的子类对其进行实例化
匿名内部类
不用声明实质上的类，就可以使用。匿名内部类（anonymous inner class）的好处是可利用内部类创建不具有名称的对象，并利用它访问到类里的成员。
异常处理
java中的异常：异常也称为例外，是在程序运行过程中发生的、会打断程序正常执行的事件
常见异常：
1、算术异常（ArithmeticException）。
2、没有给对象开辟内存空间时会出现空指针异常（NullPointerException）。
3、找不到文件异常（FileNotFoundException）。
在Java中，所有的异常都是以类的类型存在，除了内置的异常类之外，Java也可以自定义的异常类，此外，Java的异常处理机制也允许自定义抛出异常
异常处理是由try、catch与finally三个关键字所组成的程序块
try
{
要检查的程序语句 ；
}
catch(异常类 对象名称)
{
异常发生时的处理语句 ；
}
finally
{
一定会运行到的程序代码 ；
}
1、try程序块若是有异常发生时，程序的运行便中断，并抛出“异常类所产生的对象”。
2、抛出的对象如果属于catch()括号内欲捕获的异常类，则catch会捕捉此异常，然后进到catch的块里继续运行。
3、无论try程序块是否有捕捉到异常，或者捕捉到的异常是否与catch()括号里的异常相同，最后一定会运行finally块里的程序代码。
由上述的过程可知，异常捕捉的过程中做了两个判断：第一个是try程序块是否有异常产生，第二个是产生的异常是否和catch()括号内欲捕捉的异常相同。
值得一提的是，finally块是可以省略的。如果省略了finally块不写，则在catch()块运行结束后，程序跳到try-catch块之后继续执行。
异常可分为两大类：java.lang.Exception类与java.lang.Error类。这两个类均继承自java.lang.Throwable类
Error类专门用来处理严重影响程序运行的错误，可是通常程序设计者不会设计程序代码去捕捉这种错误，其原因在于即使捕捉到它，也无法给予适当的处理，如JAVA虚拟机出错就属于一种Error
Exception类包含了一般性的异常，这些异常通常在捕捉到之后便可做妥善的处理，以确保程序继续运行
抛出异常有下列两种方式：
1、程序中抛出异常 在程序中抛出异常时，一定要用到throw这个关键, throw关键字所抛出的是异常类的实例对象，因此必须使用new关键字来产生对象。
throw new ArithmeticException("一个算术异常");
2、指定方法抛出异常
如果方法内的程序代码可能会发生异常，且又没有使用代码块来捕捉，则在声明方法时一并指明所有可能发生的异常，以便让调用此方法的程序做好准备来捕捉异常。
也就是说，如果方法会抛出异常，则可将处理此异常的try-catch-finally块写在调用此方法的程序代码内
方法名称（参数…） throws 异常类1，异常类2，…
如果在类的方法中用throws抛出一个异常，则在调用它的地方就必须明确地用try-catch来捕捉
编写自己的异常类
因为所有可处理的异常类均继承自Exception类，所以自定义异常类也必须继承这个类: class 异常名称 extends Exception
包及访问权限
在大型的项目中，为了防止java类、接口的同名问题，引入了package的概念
package package名称
经过package的声明之后，在同一文件内的接口或类都被纳入相同的package中
import语句
通过import导入类名，可以访问不同package里面的public类
import package名称.类名称
在TestPackage.java中有如下语句：
package demo.java.b ; 声明package 为demo.java.b
import demo.java.a.Person ;导入package demo.java.a中的Person类
class TestPackage
{
。。。
}
注意：
1.可以将第2行的import demo.java.a.Person改成import demo.java.a.*，表示导入包中的所有类，
另外需要告诉读者的是，在java中有这样的规定：导入全部类或是导入指定的类，对于程序的性能是没有影响的，所以在开发中可以直接写导入全部类会比较方便。
2.可以不在文件前面使用import，而是直接引用带包名的类：
System.out.println(new demo.java.a.Person().talk()) ;
JDK中常见的package
1、 java.lang — 包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。在java.lang包中还有一个子包：java.lang.reflect用于实现java类的反射机制。
2、 java.awt — 包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
3、 javax.swing — 此包用于建立图形用户界面，此包中的组件相对于java.awt包而言是轻量级组件。
4、 java.applet — 包含applet运行所需的一些类。 （小应用程序（Applet）是指采用Java创建的基于HTML的程序。浏览器将其暂时下载到用户的硬盘上，并在Web页打开时在本地运行）
5、 java.net — 包含执行与网络相关的操作的类。
6、 java.io — 包含能提供多种输入/输出功能的类。
7、 java.util — 包含一些实用工具类，如定义系统特性、与日期日历相关的函数
java1.2以后的版本中，java.lang这个包会自动被导入，对于其中的类，不需要使用import语句来做导入了，如前面经常使用的System类
类成员的访问控制权限
JAVA中有四种访问控制权限，分别为：private、default、protected、public
1、private
在前面已经介绍了private访问控制符的作用，如果一个成员方法或成员变量名前使用了private访问控制符，那么这个成员只能在这个类的内部使用。
注意：不能在方法体内声明的变量前加private修饰符。
2、默认访问控制符 default
如果一个成员方法或成员变量名前没有使用任何访问控制符，就称这个成员所拥有的是默认的（default）访问控制符。
默认的访问控制成员可以被这个包中的其它类访问。如果一个子类与其父类位于不同的包中，子类也不能访问父类中的默认访问控制成员。
3、 protected访问控制符
如果一个成员方法或成员变量名前使用了protected访问控制符，那么这个成员既可以被同一个包中的其它类访问，也可以被不同包中的子类访问
4、 public访问控制符
如果一个成员方法或成员变量名前使用了public访问控制符，那么这个成员可以被所有的类访问，不管访问类与被访问类是否在同一个包中。
Java的命名习惯
包名中的字母一律小写，如：demo.java。
类名、接口名应当使用名词，每个单词的首字母大写，如：TestPerson。
方法名，第一个单词小写，后面每个单词的首字母大写，如：talkMySelf。
常量名中的每个字母一律大写，如：COUNTRY。
Jar文件的使用
jar文件就是Java Archive File，jar文件就是Java Archive File
如果开发者开发了许多类，当需要把这些类提供给用户使用时，通常都会将这些类压缩到一个jar文件中，以jar包的方式提供给用户使用。
只要别人的classpath环境变量的设置中包含这个jar文件，Java虚拟机就能自动在内存中解压这个jar文件，把这个jar文件当作一个目录，在这个jar文件中去寻找所需要的类及包名所对应的目录结构
参考书籍：Java基础教程
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
