文章摘要
1、构造方法
2、重载
3、重写
4、方法参数以及传递
5、递归
6、继承
7、多态
8、访问修饰符
9、static修饰符
10、final修饰符
11、abstract修饰符
12、interface接口
一、类
在Java中，类是对象的抽象概念。在一个类中，包括属性、方法等。
public class 计算器 {
//1、定义类成员变量mCurrentResult ： [数据类型] [变量名]
public String mCurrentResult;
/**
* 2、方法
* 将结果输出到屏幕
* @param message
*/
public void print(String message){//message局部变量
mCurrentResult = message;
System.out.println("计算结果："+mCurrentResult);
}
}
类的初始化以及使用：
//使用new关键字，得到一个计算器对象 calc。
计算器 calc = new 计算器();
//在计算器上，打印 0.
calc.print("0");//计算结果：0
类名：
- 类名使用英文来命名，不建议使用中文。
- 类名首字母大写
类名最好和实际使用的场景有意义，例如：Person，比Aaa要好上太多。
二、属性
在类中，可以定义静态常量，也可以定义变量，这些都属于类的属性。变量按照作用范围，又分为成员变量和局部变量。格式：【数据类型 名称 = 值】
如上文的代码案例：mCurrentResult 成员变量，message局部变量。
三、方法
3.1、方法的四要素:方法返回值类型、方法名称、形式参数、方法体。
//【修饰符】 【返回值类型】 【方法名称】（形式参数列表）{
// //方法实现主体
// //return 返回值。
// }
public int sum(int number1,int number2){
return number1+number2;
}
3.2、构造方法：
构造方法：
1、方法名必须与类名完全匹配。
2、不含有返回类型
3、不能被描述符修饰
ps：当定义一个类时，会默认含有一个隐式、无参构造方法。
public 计算器(){
System.out.println("欢迎使用计算器");
}
public 计算器(String msg){
this.mCurrentResult = msg;
System.out.println("初始屏幕显示："+msg);
}
3.3、方法重载
重载：在一个类中，含有相同的方法名称，但是：参数列表（参数的类型、个数、顺序）不同的多个方法。例如：３.２中的两个构造方法。
3.4、方法重写
重写：在一个类中，子类对父类中的方法，进行重新实现。拥有相同的方法名称、返回值、形参列表。
- 重写方法不能比被重写的方法又严格修饰权限。
- static修饰的方法，无法被重写。
3.5、方法参数以及传递
Java语言中，方法中参数的赋值，只采用传值的方式，按照类型又分为：基本数据类型、引用数据类型。
基本数据传递：
int x = 5;
System.out.println("调用前："+x);
change(x);
System.out.println("调用后："+x);
public static void change(int x){
x = 300;
System.out.println("执行中："+x);
}
输出：
调用前：5
执行中：300
调用后：5
引用数据传递：
calc.mCurrentResult = "调用方法前";
System.out.println("方法调用前："+calc.mCurrentResult);
change(calc);
System.out.println("方法调用后："+calc.mCurrentResult);
public static void change(计算器 calc){
calc.mCurrentResult = "调用change方法";
System.out.println("方法执行中：currentResult："+calc.mCurrentResult);
}
输出：
方法调用前：调用方法前
方法执行中：currentResult：调用change方法
方法调用后：调用change方法
3.6、递归调用
//计算从1到10的加法和
int sumCount = sum(10);
System.out.println("sumCount is:"+sumCount);
private static int sum(int n){
if(n==1){
return 1;
}else{
return n+**sum(n-1)**;
}
}
四、this关键字
this：当前对象的引用。
public 计算器(String mCurrentResult){
this();
this.mCurrentResult = mCurrentResult;
System.out.println("初始屏幕显示："+mCurrentResult);
}
- 当方法的参数名称与类的成员变量相同时，使用this可以用来明确变量的作用范围。例如：上面的代码，方法的mCurrentResult与类的成员变量mCurrentResult，相同。
- 调用本类的其他构造方法，如上面的例子中的this（）；
** 五、继承 **
1、类可以继承父类，成为一个子类。2、继承是“is-a”关系。3、子类可以通过继承，来获得父类的特性。4、Java只支持单继承：一个类只能有一个父类，但一个父类可以派生多个子类。
public class Person {
public String name;
public Person(String name){
this.name = name;
}
public String toDesc() {
return "Person [name=" + name + "]"
+",两条胳膊，两条腿。";
}
}
Super：同“this”关键字一样，Super代表父类的引用
public class 稻草人 extends Person{
public 稻草人(String name) {
super(name);
}
@Override
public String toDesc() {
return super.toDesc();
}
}
六、多态
1、子类可以自动向上转型为父类型。
２、父类型要转换为子类型，必须强制类型转换。但强转有风险。比如：类型转换操作。
java.lang.ClassCastException
３、可以使用instance of来甄别对象类型。
//1、初始化基本的人对象
Person person = new Person("某某某");
System.out.println(person.toDesc());//Person [name=某某某],两条胳膊，两条腿。
//2、向上转型
Person 稻草Person = new 稻草人("卫兵");
System.out.println(稻草Person.toDesc());//名字叫做卫兵的稻草人,两条胳膊，一条腿。
//3、可以通过instance of来甄别对象的类型
boolean isPersion = 稻草Person instanceof Person;
System.out.println(isPersion?"稻草Person 是 Person。":"稻草Person不是Person类型。");//稻草Person 是 Person。
//4、向下转型,需要强制类型转换,将类型为"Person"的稻草Person，强制转换为 稻草人。
稻草人 daocao = (稻草人) 稻草Person;
System.out.println(daocao.toDesc());//名字叫做卫兵的稻草人,两条胳膊，一条腿。
七、访问修饰符
private：私有的。只有在类中才能访问，只能修饰属性和方法。
protected：受保护的。该类以及其成员均可以访问，同一个包中的类也可以访问。只能修饰属性和方法，不能修饰类。
public：公开的。
Default：不使用修饰符。只有同一包中的类可以访问。
八、static
使用static修饰的变量叫做静态变量、修饰的方法叫做静态方法，修饰的代码块叫做静态代码块。
static属于类共有，不属于某个对象，优先加载。
public class 男人 extends Person{
static{
System.out.println("静态代码块！");
}
public 男人(String name) {
super(name);
System.out.println("构造方法！");
}
public static void main(String args[]){
男人 man = new 男人("张三");
}
}
输出：
静态代码块！
构造方法！
静态代码块中的方法，优于对象的构造方法而先执行。
九、final修饰符
final：终极
1、final修饰的类不能被子类继承，所有方法都为隐式final方法。
2、final修饰的方法，不能被子类覆盖
3、final修饰的变量，只能初始化一次。
十、abstract
abstract修饰的类，不能被实例化，即：不能通过new实例化
十一、接口Interface
抽象类型，编程超类型。
接口中定义的变量，默认为：public static final ,变量值不可修改。
