类、方法、对象与变量
在这里记录的是部分常见的方面，至于其它方面就不多说了。
一、类（属性与方法的载体）
这里主要说的是具体类，抽象类，接口；
1.具体类：
具体类也是我们最常用到的类，主要有是由以下形式出现：
[访问权限修饰符] [修饰符] class 类名 { 类体 }；其中修饰符可有可无。
示列：public class test{
public static void main（String[] args）{
System.out.println("这是一个具体类的main方法");
}
}
2.抽象类：
抽象类是在具体类的基础上加了一个为abstract的修饰符；因此抽象类大致具有以下特性：
1、不能实例化;
2、抽象类中既可以有普通方法，也可以有抽象方法；
3、继承了抽象类的类必须重写抽象类中的抽象方法；至于普通方法，可以不重写，如果重写了的话，调用的就是继承了抽象类的类重写了后的方法，反则调用的是抽象类中的方法。
示列：
package com.test;
public abstract class Abstract {// 抽象类
public void test() {
System.out.println("抽象类");
}
public void test0() {
System.out.println("抽象类0");
}
abstract void test1();// 抽象方法
}
package com.test;
public class Classes extends Abstract {
public void test0() {
System.out.println("具体类");
}
@Override
void test1() {
System.out.println("抽象方法");
}
}
package com.test;
public class Main {
public static void main(String[] args) {
Classes classes = new Classes();
classes.test();
classes.test0();
classes.test1();
}
}
最后打印出来的结果便是：抽象类
具体类
抽象方法
3.接口：
将具体类的class部分用interface替换了之后便是一个接口类
接口具有以下特性：
1、比抽象类更抽象，它的类体中只能有抽象类；
2、接口类体中的属性默认都是被public、static、final修饰的，而它的方法则默认都是被public、abstract修饰的；
3、接口只能被实现，不能被继承；由于JAVA中是单一继承多重实现，因此利用接口可以实现多重继承；
示列：
package com.test;
public interface Interface {
String a="1";//相当于 public static final String a = "1";
void test2();//相当于 public abstract void test();
}
package com.test;
public interface Interface0 {
void test3();
}
package com.test;
public class Classes extends Abstract implements Interface , Interface0{
public void test0(){
System.out.println("具体类");
}
@Override
void test1() {
System.out.println("抽象方法");
}
@Override
public void test2() {
System.out.println("第一个接口实现类");
}
@Override
public void test3() {
System.out.println("第二个接口实现类");
}
}
package com.test;
public class Main {
public static void main(String[] args) {
Classes classes = new Classes();
classes.test2();
classes.test3();
}
}
最后打印出来的结果便是：第一个接口实现类
第二个接口实现类
二、方法（即抽象出来的对象的行为）
方法的组成部分：[访问权限修饰符]+[修饰符] +返回类型+方法名（参数）+{方法体}
注：抽象方法的修饰符为 abstract 且无方法体；而一般的方法的返回类型默认都为空，即返回类型为void。
在这里主要说的则是方法重写、方法重载以及构造方法；
1.方法重写：
方法重写一般都是子类继承了父类后重写父类的方法；重写后的方法后，在子类中重写的方法将覆盖父类的方法；且重写的方法除了方法体可以不同外，其他部分都是相同的；
示列：
package com.test;
public class Classes{
public void test4(){
System.out.println("方法重写");
}
}
package com.test;
public class Classes1 extends Classes{
@Override
public void test4() {
System.out.println("子类方法重写");
}
}
package com.test;
public class Main {
public static void main(String[] args) {
Classes1 clasese1 = new Classes1();
clasese1.test4();
}
}
最后打印出来的结果便是：子类方法重写
2.方法重载：
只要类名相同参数不完全相同的两个方法都属于方法重载；
示列：
package com.test;
public class Classes{
public void test4() {
System.out.println("子类方法重写");
}
public void test4(int i){
}
public void test4(String str){
}
public void test4(String str,int i){
}
public void test4(int i ,String str){
}
}
3.构造方法：
每个类都会默认一个参数空的构造方法，在实例化该类的时候便会默认调用该构造方法；但也可以写一个参数不为空的构造方法，如果要调用的话，在实例化该类的时候添加一个对应类型的值便可，此时调用的便不是默认的构造方法而是自己写的构造方法；
示列：
package com.test;
public class Classes{
public Classes(){
System.out.println("String");
}
public Classes(int i){
System.out.println("int");
}
}
package com.test;
public class Main {
public static void main(String[] args) {
Classes classese = new Classes();
Classes classese1=new Classes(1);
}
}
最后打印出来的结果为：String
int
三、对象与变量
这里主要说的是对象与变量的区别:
简单的来说对象new了一个实例化对象而变量没有，也就是说对象开辟了一个新的内存空间，而变量使用的是栈内存；因此，对象可以调用方法与属性，而变量不能；从某种意义上来说，变量只是起到了传值的作用而已，所以变量可以说只能用八大基本数据类型来定义；同时在这里说说八大基本数据类型的包装类以及拆箱与装箱，与包装类相对的便是基本类型；
八大基本数据类型的包装类：
byte--Byte
short--Short
int--Integer
long--Long
char--Char
float--Float
double--Double
boolean--Boolean
示列：
double i=1.2; //定义了一个double类型的变量;基本类型。
Double iii=1.2//double类型的对象；由于是用Double直接定义的，所以为自动装箱。
Double iii=new Double(1.2);//double类型的对象；由于是new出来的对象，所以为手动装箱。
double ie=iii+i；//由于i是基本数据型，iii是包装类，如果要和基本数据类型i进行运算就得自动拆箱成基本数据类型；这就是自动拆箱。
int a=(int) i;//double变量转换为int类型，强制转换；
int aa=ii.intValue();//double对象转换为int类型
注：高精度的转为低精度，多出的小数部分不是四舍五入，而是直接舍弃。
Emma，最后再加一个命名规范吧：
类名：首字母大写+驼峰命名法（单词与单词间的首字母大写）；
方法名：首字母小写+驼峰命名法；
对象与类：首字母小写+驼峰命名法。