1.1 创建学生类①创建学生类
包括:
属性:姓名，年龄，电话，爱好
方法一:
自我介绍(无参，无返回值)
输出姓名，年龄，电话，爱好
方法②:
上网(有参，无返回值)
参数:上网小时，每小时多少钱
输出:上网多长时间，花了多少钱。
②使用学生类,创建两个学生对象；
调用自我介绍方法，输出学生信息；
调用上网方法，输出上网信息。
public class Student {
String name;
int age;
long phone;
String hobby;
public Student() {
}
public Student(String name, int age, long phone, String hobby) {
this.name = name;
this.age = age;
this.phone = phone;
this.hobby = hobby;
}
public void intro(){
System.out.println(this.name+"n年龄"+this.age+"n电话:"+this.phone+"n爱好"+this.hobby);
}
public void internet(int hour,int pay){
System.out.println(this.name+"上网了"+hour+"小时,花了"+(pay*hour)+"元");
}
}
1.2 使用学生类
public class Test {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.name = "张三";
stu1.age = 20;
stu1.phone = 18278945612L;
stu1.hobby = "足球";
Student stu2 = new Student();
stu2.name = "李四";
stu2.age = 18;
stu2.phone = 18377788899L;
stu2.hobby = "篮球";
stu1.intro();
stu2.intro();
stu1.internet(2,5);
stu2.internet(4,5);
}
}
2.成员方法
构造方法的作用是为了创建对象。
成员方法是为了实现某个具体的功能。
语法：
[访问修饰符] 返回值类型 方法名([参数列表]){
方法体
return 返回值;
}
说明：
[访问修饰符]：中括号在语法描述上表示这个部分可以省略；
访问修饰符：表示定义的方法能够被访问的一个范围；
属性/方法的访问修饰符总共有四个级别：public，protected，默认，private；
返回值类型：必须要有；
void：表示这个方法不需要返回结果；
其他任何类型(基本类型/引用类型)：表示方法必须要有返回值，且返回值的类型要和定义的类型一致；
方法名：自己定义，按照标识符的规则(字母，数字下划线),按照小驼峰命名；
参数列表：可以省略，省略的时候表示这个方法不需要参数；如果有参数，那么在调用方法时必须要按照参数列表的定义传递参数(参数可以是各种类型的数据);
方法体：方法实现具体功能的代码部分；
返回值：要和方法的返回值类型结合使用；
如果返回值类型时void，那么该方法不能有返回值(要么没有return,要么return后面不要写数据)；如果返回值的类型不是void，是其他类型，那么此方法最终一定要有返回值，而且返回的数据要和返回值类型对应。
//无返回值的方法
public void eat(String food){
System.out.println(this.name+"在吃"+food);
}
//带返回值的方法
public String buy(double money){
if(money<=1.5){
return "矿泉水";//返回的具体值必须是定义的类型的值
}else {
return "方便面";
}
}
// 带返回值的方法的调用
String res=stu.buy(5.5);
System.out.println(res);
小结：
①能够完成特定功能的方法就是普通方法/成员方法； ②方法要定义在类中，多个方法在类中定义的次序没有要求； ③ 方法之间可以相互调用，但是不能形成循环调用，否则会内存溢出； ④ 方法定义后需要通过对象调用才能执行； ⑤ 如果方法是有参数的，则调用方法时必须按参数类型和次序传参； ⑥如果方法定义了返回值的类型，则方法执行后必须按照返回值的类型返回数据。如果方法代码块中存在分支结构需要确保最终方法执行完成的时候是有返回值的；如果方法没有返回值（即返回值类型是void），测试方法可以不写return，也可以写return，但是return后面不能跟数据，return的作用是终止方法执行。3.方法重载 3.1为什么需要方法重载？
在一个类中可以有很多的方法，并且每一个方法都有自己的功能，但是方法太多，对开发者不友好，名字太多不好记，所以使用方法重载，控制每一个方法中传入的参数，并且方法的名字都一样，Java会自动的根据传入参数的不同，调用参数相应的方法。
3.2什么是方法重载？方法重载 : 在一个类中，方法名相同，参数不同（个数不同，类型不同，次序不同），构成方法重载； 方法重载与访问修饰符，返回值类型，方法参数名没有关系； 作用 : 方便使用者调用方法。
public class Sum {
public void add(int x,int y){
System.out.println(x+y);
}
public int add(int x,int y,int z){
return x+y+z;
}
public void add(int x,double y){
System.out.println(x+y);
}
public void add(String x,String y){
System.out.println(x.equals(y));
}
public double add(double x,int y){
return x+y;
}
}
4.包和访问修饰符 4.1包特点：
①函数/方法名相同；
②参数列表不同(参数个数不同，顺序不同，参数类型不同)。
注：方法重载不考虑返回值，不考虑参数名，不考虑访问修饰符。
包的作用，用于分门别类，不同的类放在不同的包中用于区分。
4.1.1 为什么需要包①没有包的话，类多的时候不好找，所以包的作用在于管理类，包在磁盘上的体现就是文件夹；
②不同包下的类可以重名(同一目录类不能重名)；
③可以通过包做一些限定。
4.1.2 包的定义语句package 包名;
4.1.3 跨包请求的时候需要导入包import 包名.类名;
导入指定类import 包名.*;
System.out.println()、String、int、boolean：属于 java.long 包下的内容，每一个类都会自动引入java.lang包。
4.2 权限/访问范围修饰符使用修饰符定义了类和类中的字段或方法时，就可以限定该类或类中字段或方法能被哪些范围的类或哪些方法来使用。
①类的修饰符(两种)：public，默认(不写的时候就是默认)
public：所有包中都可以访问，
默认：同包下的类可以访问，其他包的类不能访问；
②类中属性/方法的修饰符(四种)：public(公有),protected(受保护)，默认，private(私有)
作用：权限的设置，保护属性不被外界侵犯。
// 访问修饰符:
// 针对类的 public , 默认 // 针对属性和方法的 public,protected, 默认 ,private // public: 在任意包任意类中可以访问到 // private: 只在当前类中能被访问，其它包其他类都不能访问 // 默认 ( 不写访问修饰符 ): 在同包的类中可以访问，在其它包的类中不能访问
默认：default
4.3 static 关键词static：静态的
用来修饰属性(成员变量),则该属性就成为类属性(不依赖于某个对象而存在)，所有该类的实例对象都共用这一个属性，任何一个实例改变了静态属性值，大家看到的都是修改过的值；在内存中static属性是所有类实例公有的内存地址。
static来修饰方法，该方法就成为静态方法，可以直接通过类名访问，一般在工具类中定义工具方法。
静态变量和实例变量的区别: ①实例变量，依赖于实例对象而存在,访问实例变量的时候，必须通过实例对象来访问; ②实例变量，在内存中可以有多份(内存中创建了多少实例对象，就有多少实例变量)，每个实例对象的实例变量互不影响; ③静态变量，不依赖于对象而存在，直接与类关联，可以通过类名来访问； ④静态变量，在内存中只有一份，被所有实例对象共享。 static的使用场景：static修饰的变量叫静态变量； static修饰的方法叫静态方法； static修饰的代码块叫静态代码块。
static的特点：
所有的静态（静态变量和静态方法）都属于类 （全局） ①静态属性和静态方法可以直接通过 【 类名.静态属性】【类名.静态方法() 】 来使用，这是推荐的方式，当然也可以通过实例对象来访问静态属性和静态方法，但是不推荐； ②静态方法中，只能访问静态属性和其它静态方法，不能访问实例属性和实例方法； ③实例方法中，可以访问静态属性和静态方法，也可以方法实例属性和实例方法； ④ 静态代码块，在类被加载时自动调用。
public class Saler {
//姓名
String name;
//票数
static int ticket=10;
public void sale(){
//Saler.ticket
if(this.ticket>0){
this.ticket--;
System.out.println(this.name+"卖票一张,剩余:"+this.ticket);
}else{
System.out.println(this.name+"票已卖完");
}
}
}
public class MyCls {
//实例代码块:每次创建对象的时候，都会在构造方法之前执行一次
{
System.out.println("实例代码块被执行");
}
//只在加载类的时候，执行一次
static {
System.out.println("静态代码块被执行");
}
public MyCls(){
System.out.println("构造方法被执行");
}
}
public class Student {
String name;
int age;
//静态变量被共享
static int x = 100;
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void introduce(){
System.out.println(this.name+" "+this.age+" "+x);
}
}
public static void main(String[] args) {
//static 静态
//静态属性/静态方法
//静态属性:直接与类关联，内存中只有一份，被所有该类的对象共享
//静态变量直接通过类名访问，与实例没有关系。被实例对象共享
Student.x=500;
Student s1 = new Student("张三",20);
Student s2 = new Student("李四",18);
s1.introduce();
s2.introduce();
System.out.println("========================");
//修改s1的姓名为张三丰
s1.name="张三丰";
//通过s1将静态变量x改为200
s1.x=200;
s1.introduce();
s2.introduce();
}
public static void main(String[] args) {
System.out.println(x);
System.out.println(Test.x);
//System.out.println(num);
//System.out.println(Test.num);
Test t = new Test();
System.out.println(t.num);
//通过类直接调用静态方法
Test.ccc();
}
//成员变量/全局变量/实例变量
int num;
static int x;
//普通方法/成员方法/实例方法
public void aaa(){
System.out.println(num);
bbb();
System.out.println(x);
ccc();
}
public void bbb(){
}
public static void ccc(){
//System.out.println(num);
//bbb();
System.out.println(x);
ddd();
}
public static void ddd(){
}
