面向对象----类（class）_class声明类

1、声明类的语法格式：
    【修饰符】 class 类名{
        成员列表
    }

（1）【修饰符】后面一一讲解，比如：public（公共的）等，也可以缺省/省略。
    如果一个类前面加了public，就要求.java源源文件名 必须 与这个类名一致。
    意思就是说：public class TestClass{..}
              这个类必须在 TestClass.java文件中，否则就报错。

     换句话说，一个.java源文件中，不能同时出现两个public类

     补充问题：
        建议，如果一个.java源文件中有多个类，那么包含main的主类是那个public的类。
（2）class：声明类的关键字，class是小写的
每一个class，都会有自己的独立的.class文件。.class文件名就是类名

（3）类名：
    每一个单词的首字母大写，形式：XxxYyyZzz，尽量见名知意
（4）类的成员有5大类
   A：成员方法
   B：成员变量
   C：构造器
   D：代码块
   E：内部类

2、如何创建对象？
（1）new 类名()
new 类名()称为new表达式，它可以直接加;成独立的语句。
通常情况下，都是要把new表达式，用变量接收的，否则就是匿名对象。

（2）变量 = new 类名();
这个变量的类型必须>=new后面的类。 

类名  变量 = new 类名();

回忆：
Scanner input = new Scanner(System.in); 也是创建对象，创建的是Scanner类型的对象。
                                后面再给大家讲解new 类名(参数)的情况。

（3）接收对象的变量，是引用数据类型
Java的数据类型：
A：8种基本数据类型
B：引用数据类型：类类型、数组类型等
凡是引用数据类型的变量，里面存储的都是“首地址”。

延伸：为什么像类、数组类型的变量，称为引用数据类型？
因为类、数组类型的变量中存储的是某个对象（数组对象、类的对象）的首地址，相当于我们通过这个变量名可以引用
数组或类中的成员，例如：数组名.length，数组名[下标]访问元素。
                      Teacher t1 = new Teacher();
                      t1.name = "宋老师";
                      t1.gender = '男';
                t1可以引用到Teacher类的成员，即t1可以.出name和gender。

  另外，引用数据类型的变量中存储了首地址，就可以指向对象的内存空间，取出它里面的值。

  因此这个变量也称为对象的引用。

成员变量

1、什么是成员变量？
声明在类中方法外的变量，称为成员变量。
与之对应的，声明在方法里面的变量，称为局部变量。

2、成员变量的声明格式？
【修饰符】 class 类名{
    【修饰符】 数据类型  成员变量名;

}

成员变量前面可以加【修饰符】，例如：public, static ,final等

3、如何使用成员变量？
（1）在其他类中使用
    对象.成员变量
     补充：
    如果是静态变量，我们建议使用“类名.静态变量”的方式访问。

（2）在本类中使用

4、成员变量有默认值
byte,short,int,long：0
float,double：0.0
char：\u0000的空字符，编码值为0的空字符
boolean：false
引用数据类型：null
    例如String类型是引用数据类型，默认值是null

5、成员变量的特点
（1）成员变量有默认值
（2）补充：
非静态成员变量：每一个对象都是独立的。
静态成员变量：所有对象共享的。

public class TestField {
    public static void main(String[] args) {
        int a;//声明一个int类型的变量，变量名叫做a
                //它是在方法里面声明的，称为局部变量
        //System.out.println(a);//未初始化错误
 
//        System.out.println(name);//报错，不能直接使用另一个类的成员变量
        //创建Student的对象
        Student stu = new Student(); //这里stu变量就是代表new Student()对象，所以把stu直接叫做对象
        Student two = new Student();
 
        //然后通过Student的对象，这里用stu代表了
        System.out.println(stu.name);//null 直接显示stu对象的name成员变量值
        System.out.println(stu.score);//0 直接显示stu对象的score成员变量值
 
        stu.name = "张三"; //给stu对象的name成员变量赋值
        stu.score = 99;//给stu对象的score成员变量赋值
 
        System.out.println(stu.name);//张三
        System.out.println(stu.score);//99
 
        System.out.println(two.name);//null  stu对象虽然给name和score赋值了，但是和two对象无关。
        System.out.println(two.score);//0
    }
}
 
//同一个.java文件中，谁在上面谁在下面没关系，它们是并列的。
class Student{
    String name;//声明一个String类型的变量，变量名叫做name
    int score;//声明一个int类型的变量，变量名叫做score
                //它俩都在类中，但是不在方法里面，所以称为成员变量
}

静态变量

1、什么情况下需要声明静态变量呢？
当某个成员变量的值，不需要每一个对象单独存储一份，是所有对象共享的。
那么这样的成员变量就可以声明为静态变量。

2、如何声明静态变量？
【修饰符】 class 类名{
    【其他修饰符】 static 数据类型  静态成员变量名;
}

3、静态变量的使用
（1）在其他类中使用
对象.静态变量（可以，但是不推荐）
类名.静态变量（推荐）
    为什么推荐类名.静态变量使用方式？
    因为这样的可读性更好。
    通过类名.静态变量的形式，一看就知道不是单独访问某一个对象的信息，是所有对象共享的信息。

（2）在本类中使用

什么情况下使用静态方法呢？
（1）工具类，
工具类中的每一个方法基本上是独立的，和工具类本身的对象无关，只是负责完成某个功能。
例如：Math类

（2）在非工具类，和静态变量有关，而和非静态的成员变量无关的功能，这种方法也声明为静态
因为方法声明为静态的，有一个好处，就是调用方便，可以通过“类名.静态方法"直接调用。

4、成员变量的内存分析
静态变量：方法区，一个类存储一份，所有对象共享
非静态成员变量：堆，一个对象存储一份，所有对象独

 

 

public class TestStaticField {
    public static void main(String[] args) {
        //创建Chinese对象
        Chinese c1 = new Chinese();
        c1.name = "张三";
//        c1.country = "中国";  //容易让人误解为只是修改c1对象的country值
        Chinese.country = "中国";//推荐写法
 
        Chinese c2 = new Chinese();
        c2.name = "李四";
        //此处并没有为c2的country赋值
 
//        System.out.println("c1的姓名：" + c1.name +"，国家名：" + c1.country);
//        System.out.println("c2的姓名：" + c2.name +"，国家名：" + c2.country);
        //发现c2.country的值也是“中国”，因为它和c1对象共享同一个country的值
 
        //推荐下面的写法，静态变量使用“类名.静态变量”
        System.out.println("c1的姓名：" + c1.name +"，国家名：" + Chinese.country);
        System.out.println("c2的姓名：" + c2.name +"，国家名：" + Chinese.country);
 
    }
}
 
//这个类表示中国人
class Chinese{
    String name;//每一个中国人都有自己的名字，大家的名字是独立的，所以name不是静态的
    static String country;//所有中国人的国家名字是同一个，是共享的，所以country是可以声明为静态
}

包

1、为什么要声明包？
（1）避免类的重名
一旦类放到了包中，或者说一旦某个类声明了包，那么类的全名称，就是“包.类名"。
包名+类名的重名概率就非常低。

（2）可以分类管理众多的类
（3）限定某些类或某些类的成员的可见性范围
如果某个类的class前面不是public，就不能跨包使用。
如果某个类的成员（成员变量、成员方法等）前面没有public，也不能跨包跨包使用。 这里不讨论子类问题

2、如何声明包？
必须使用package语句，格式：
package 包名;

要求：
（1）package语句必须在.java源文件的代码首行，一个.java文件中只能有一个package语句
（2）包名习惯上是所有单词都小写，每一个单词之间（每一级包之间）使用.分割。
（3）包名习惯上使用  公司域名倒置 + 不同主题
例如：讲解oop的知识点，com.atguigu.oop

尚硅谷：www.atguigu.com

一级域名：com：商业公司
        org：非营利性的组织
        gov：政府
        edu：教育
（4）自定义的 包名中不要包含java单词，更不要用java.开头。否则使用就会有问题。

3、如何使用其他包的类
两种方式：
（1）使用类的全名称：麻烦
（2）使用import语句 + 简名称
A:一个.java文件中关于某个类只需要导一次就可以。
B:不同的类，可以分别使用多个import语句导入
C：如果被使用的很多个类都在一个包中，可以简写import语句
import 包.*;
D：如果使用多个不同的包的同名的类，只能一个使用import,其他的使用全名称
E：import语句的位置在package和class声明之间

4、在命令行中，如何编译和运行带包的类？（了解中的了解，知道一下就可以了，后面都是IDEA中使用）
在命令行中编译带包的.java文件：javac -d . 源文件名.java
-d：生成包目录结构
.：在当前路径下生成包目录结构

在命令行中运行带包的主类：java 包名.类名

成员方法

1、方法：是一个独立的可复用的功能。
2、当某个类的事物具备某个功能时，可以使用方法来表示。
例如：
 Circle类的事物圆具备“求面积”的功能。可以用方法来表示。

3、同一个类的成员方法与成员变量的使用问题？
        非静态的方法 ： 可以直接使用本类的非静态的成员变量，非静态方法
        静态的方法  ：  可以直接使用本类的静态的成员变量，静态方法
        非静态的方法 ： 可以直接使用本类的静态的成员变量，静态方法
        静态的方法  ： 不可以直接使用本类的非静态的成员变量，非静态方法  （*****）

结论：同一个类中的成员方法可以直接使用同一个类的成员方法和成员变量，除了一种情况不能用，静态的不能直接用非静态的。

为什么？
（1）静态的是和对象无关的，是属于类
    非静态的是属于对象的。

（2）类的生命周期更长，先有类，后有对象。
    静态的先有， 非静态的是后有，
    先有的是不能直接使用后有的。

    举个不是很恰当的例子，但是可以说明问题。
    秦始皇是先有的，手机是后有的，秦始皇是不能用手机。

4、一个类如何使用其他类的方法？
（1）非静态的方法
  对象.非静态方法

（2）静态方法
类名.静态方法（推荐）
对象.静态方法（不推荐）

5、成员方法的内存分析
1、原则：方法不调用不执行，调用一次执行一次。
2、方法调用时，会在栈中开辟一块独立的内存空间，用来存储方法的局部变量等信息，这个过程称为“入栈”。
方法调用结束，就会立刻是否对应的栈内存，这个过程称为“出栈”。

 方法的调用过程：main入栈->println入栈-> area()入栈 -->area出栈-->println出栈->另一次println入栈-->add方法入栈-->add出栈-->println方法出栈->
最后一次println入栈-->add入栈-->add出栈-->println出栈-->main出栈

public class TestMethod {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        c1.radius = 1.2;
//        System.out.println("半径：" +  c1.radius + "，面积：" + c1.area());
        System.out.println(c1.getInfo());
 
       // System.out.println(Circle.getArea(1.2));//单独求面积，和对象无关
       // System.out.println(c1.getArea(1.2));//此时只是通过c1调用了一下getArea方法，但是这个功能本身和c1无关的。
    }
}
 
class Circle{
    double radius;
 
    //“求面积”的功能
    double area(){
      
        return Math.PI * radius * radius;
    }
 
    String getInfo(){
        //在这里getInfo()方法，直接使用本类的非静态成员变量radius和非静态成员方法 area()
        return "半径：" + radius +"，面积：" + area();
    }
 
    //静态方法getArea和Circle的对象无关
    public static double getArea(double radius){
        return Math.PI * radius * radius;
    }
}