为什么 sum=score1+score2;return sum;这样不可以

你没有定义属性吧

public static int sum(){      //这一行的sum是一个方法名

     sum=score1+score2;       //最后两行sum是属性，需要定义

     return sum;

} 

还有属性和方法都是类的成员，尽量不要相同，可以改成

public static int sum(){      //这一行的sum是一个方法名

     int sum1;

     sum1=score1+score2;       //最后两行sum是属性，需要定义

     return sum1;

} 

或者直接 return score1+score2；

为什么int what=score1+score2；
return what不行
我调用sun方法时，我知道这个方法是求和，它会返回一个值，当我需要多次使用它时，我会声明一个变量取个合适的变量名用来接收这个值，我并不需要sum方法里有个变量被赋予这个值，因为很多余，例如你写的what，它只是一个局部变量，我在别的方法里没法调用，这个方法的作用就是求和然后把结果这个值传递，所以直接return score1+score2即可，你先做的int what = score1 +score2 ;其实也就是将结果这个值赋给了what然后return what，最终结果也是传递这个值，所以没必要声明这个what变量在栈区中，很多余很浪费

普通成员方法：

静态变量        （直接访问）

-非静态变量     （直接访问）

 -静态方法        （直接调用）

 -非静态方法    （通过对象访问）

/静态方法：

public static void print() {

System.out.println("静态方法调用执行==");

//静态方法可以直接调用同类中的静态成员：

System.out.println("调用同类中的静态成员："+ hello);

//不能直接调用非静态成员：

//System.out.println("调用静态成员"+ vae);

//通过对象来调用非静态成员，对象必须是在方法体内创建才有效调用，在方法体外创建的类对象调用非静态成员是无效的

tesedemo tesed = new tesedemo();

System.out.println("通过对象调用非静态成员：" + tesed.vae);

} 

//==================================================================================

//普通成员的方法中，可以直接访问同类中的  非静态变量与 静态变量：

public void pel() {

String huy = "方法体中的非静态变量";

// 普通方法体内调用静态方法是允许的

print();

//普通方法可以直接访问同类中的 静态变量

System.out.println("普通方法访问 静态变量："+ hello);

//普通方法可直接访问非静态变量

System.out.println("普通方法访问非 静态变量："+ huy);

//调用普通方法须通过类的对象调用

System.out.println("调用普通方法须通过类的对象调用");

// 注： 因程序入口"main" 是静态方法，在调用普通方法时必须是对象调用。而定义的静态方法可直接访问方法名

类，抽象概念

对象，将类实体化

为什么 sum=score1+score2;return sum;这样不可以

你没有定义属性吧

public static int sum(){      //这一行的sum是一个方法名

     sum=score1+score2;       //最后两行sum是属性，需要定义

     return sum;

} 

还有属性和方法都是类的成员，尽量不要相同，可以改成

public static int sum(){      //这一行的sum是一个方法名

     int sum1;

     sum1=score1+score2;       //最后两行sum是属性，需要定义

     return sum1;

} 

(类  属性 方法)

public void,  public static void ,   static voide  ,static   ,void  这些都有啥区别。。
public / protected / private 是权限修饰符，void是返回类型修改符，static是静态修饰符

package che;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Scanner;

public class ciche {

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.print("欢迎进入租车系统\n");

List<Map<String, String>> list = new ArrayList();

Map<String, String> map = new HashMap<String, String>();

map.put("userid", "1234");

map.put("pwd", "123");

Map<String, String> map1 = new HashMap<String, String>();

map1.put("userid", "4567");

map1.put("pwd", "456");

Map<String, String> map2 = new HashMap<String, String>();

map2.put("userid", "7894");

map2.put("pwd", "789");

list.add(map);

list.add(map1);

list.add(map2);

Scanner in = new Scanner(System.in);

System.out.println("请输入用户名：");

String userid = in.next();

boolean flag = false;

for (Map<String, String> user : list) {

if (userid.equals(user.get("userid"))) {

flag = true;

System.out.println("请输入密码：");

String pwd = in.next();

if (pwd.equals(user.get("pwd"))) {

System.out.println("登录成功");

System.out.print("您可租车的类型：\n");

System.out.print("1是皮卡，2是卡车，3是汽车\n");

Scanner d = new Scanner(System.in);

int c = in.nextInt();

if (c == 1) {

pik ik = new pik();

ik.name();

Scanner v = new Scanner(System.in);

int a = in.nextInt();

int n = 500;

int sum = n * a;

System.out.print("您一共需要支付" + sum + "元\n");

}

if (c == 2) {

pik ik = new pik();

ik.name();

Scanner v = new Scanner(System.in);

int a = in.nextInt();

int n = 500;

int sum = n * a;

System.out.print("您一共需要支付" + sum + "元\n");

}

if (c == 3) {

pik ik = new pik();

ik.name();

Scanner v = new Scanner(System.in);

int a = in.nextInt();

int n = 500;

int sum = n * a;

System.out.print("您一共需要支付" + sum + "元\n");

}

} else {

System.out.println("用户名或密码错误");

}

break;

}

}

if (flag == false)

{

System.out.println("用户名不存在");

}

}

}

hobby是HelloWorld的一个string类型的变量，sum是HelloWorld的一个方法，调用变量直接 .变量名，调用方法直接 .方法名() 
第一个是访问成员变量，hobby是HelloWorld类的成员变量；而第二个是访问方法，sum()是一个方法，所以需要带括号。
调用静态方法，方法加（）,类里的静态变量不用（）

类名 对象名 = new 类名();可以创建类的对象

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

例：

  //创建外部类的对象

HelloWorld o = new HelloWorld (); 

        //创建内部类的对象

Inner inn = o.new Inner()             ;

        //调用内部类对象的show方法

inn.show();

}

}

成员变量与局部变量使用：

数据模型分析：操作（方法）、属性

业务模型分析：分析需求

显示和流程分析：1.用户可以看到的信息界面；2.流程：显示信息的执行过程、步骤；3.考虑信息如何处理，怎样呈现，怎样提示

public abstract void say();

抽象类的方法没有{}，只有()，分号结尾