java 类方法 属性_Java 基础知识（类 、 属性、方法）梳理

文章摘要

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 ,变量值不可修改。