java语法基础4（类和对象、方法、重载、可变参数、作用域、构造器、this关键字）

1.类和对象 

 1.1类与对象的概述

1.2对象的基础代码

class car{
    String name;
    double price;

    String color;
    String[] master;//属性可以是基本数据类型，也可以是引用(对象，数据)
}

package grammer;

//定义一个猫类Cat->自定义的数据类型
class Cat{
    String name;
    int age;
    String color;
}
public class class_class {
    public static void main(String[] args) {

        //1.new Cat()创第一只猫
        //2.Cat cat1  = new Cat();把创建的猫赋给 cat1
        Cat cat1 = new Cat();
        cat1.name = "小白";
        cat1.age = 3;
        cat1.color = "白色";
        //1.new Cat()创建第二只猫
        //2.Cat cat2  = new Cat();把创建的猫赋给 cat2

        Cat cat2 = new Cat();
        cat2.name = "小黑";
        cat2.age = 5;
        cat2.color = "黑色";

        //怎么使用
        System.out.println("第一只猫的信息"+cat1.name+" "+cat1.age+" "+cat1.color);
        System.out.println("第二只猫的信息"+cat2.name+" "+cat2.age+" "+cat2.color);
    }
}

1.3对象在内存中的存在形式

对象也可以将本身赋值给其他的对象名如下图的代码所示：

1.4对象的使用细节

2.方法

2.1方法的基本概述

在某些情况下，我们需要定义成员方法（简称方法）。比如人类：除了有一些属性外（在对象的介绍中提到过）我们还要描述一些行为（吃饭、跑步等），这就需要使用成员方法进行实现。

2.2方法的基础代码

package grammer;

//定义一个猫类Cat->自定义的数据类型
class Cat{
    String name;
    int age;
    String color;
    //方法(成员方法)
    //添加speak成员方法，输出“喵喵喵喵”
    //public 表示方法是公开
    //void 表示方法没有返回值
    //speak() speak是方法名,()形参列表
    //()方法体，可以写我们要执行的代码
    public void speak(){
        System.out.println("喵喵喵喵");
    }
    public void cal01(){
        int res =0;
        for(int i=1;i<=1000;i++)
        {
            res+=i;
        }
        System.out.println("计算结果="+res);
    }
    //(int n)形参列表，表示当前有一个形参n,可以接受用户输入
    public void cal02(int n){
        int res = 0;
        for(int i = 1;i<=1000;i++){
            res+=i;
        }
        System.out.println("计算结果="+res);
    }
    //(int num1, int num2)形参列表，2个形参，可以接收用户传入的两个数
    public int getSum(int num1,int num2){
        int res = num1 + num2;
        return res;//返回值
    }

}

public class class_class {
    public static void main(String[] args) {
        //方法调用
        //1.方法写好后,如果不去调用(),不会输出
        //2.先创建对象,然后调用方法即可
        Cat cat1 = new Cat();
        cat1.speak();
        cat1.cal01();
        cat1.cal02(10);

        //调用getSum方法，同时num = 10，num2 = 20
        //把方法getSum返回的值，赋给变量returnRes
        int returnRes = cat1.getSum(10,20);
        System.out.println("getSum返回的值="+returnRes);
    }
}

2.3 方法的调用机制

画出上述代码中getSum的调用机制  

2.4方法的相关细节

3.重载

3.1重载的基本概念

java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！

3.2重载的基础代码

package grammer;
class MyCalculator{
    public int calculate(int n1,int n2)
    {
        return n1 + n2;
    }
    public double calculate(int n1,double n2)
    {
        return n1 + n2;
    }
    public int calculate(int n1,int n2,int n3)
    {
        return n1 + n2 + n3;
    }
}
public class overload { 
    public static void main(String[] args){
        MyCalculator MC = new MyCalculator();
        System.out.println(MC.calculate(1,2));
        System.out.println(MC.calculate(1,1.1));
        System.out.println(MC.calculate(1,2,3));
    }
}

3.3重载的相关细节

4.可变参数

4.1可变参数的基本概念

java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

4.2可变参数的基础代码

package grammer;

public class VarParameter01 {
    public static void main(String[] args){
        HsMethod hm = new HsMethod();
        hm.sum(1,2,3,4,5,6,7);

    }
}

class HsMethod{
    //1.int...表示接受的是可变参数，类型是int，既可以接受多个int(0-多)
    //2.使用可变参数时，可以当做数组来使用即nums可以当做数组
    public int sum(int ...nums){
        System.out.println("接收的参数个数=" + nums.length);
        return 0;
    }
}

4.3可变参数的相关细节

5,作用域

5.1作用域的基本概念

5.2作用域的基本代码

package grammer;

public class VarScope {
    public static void main(String[] args){
        Cat1 c = new Cat1();
        c.eat();
        c.cry();
    }
}
class Cat1{
    //全局变量：也就是属性，作用域为整个类提 cat类：cry eat等方法使用属性
    //属性在定义时，可以直接赋值
    int age = 10;
    int Long;
    public void cry(){
        //1.局部变量一般是指在成员方法中定义的变量
        //2.n和name就是局部变量
        //3.n和name的作用只能在cry方法中
        int n = 10;
        String name = "jack";
    }
    public void eat(){
        System.out.println("在eat中使用属性age= "+age);
        System.out.println("在eat中使用属性Long="+Long);//Long 和 age都是全局变量，
                                                       //Long进行了赋值而age没有赋值
        //System.out.println("在eat中使用cry的变量name= "+name);错误
    }
}

5.3作用域的相关细节

6.构造器

6.1构造器的基本概念

构造方法又叫构造器，是类的一种特殊的方法，它的主要作用是完成新对象的初始化。

6.2构造器的基本代码

package grammer;

public class Constructor01 {
    public static void main(String[] args){
        //当我们new一个对象时，直接通过构造器制定名字和年龄
        Person p1 = new Person("smith",80);
        System.out.println("人名" + p1.age);
        System.out.println("年龄" + p1.name);
    }
}

class Person{
    String name;
    int age;
    //1.构造器没有返回值，也不能写void
    //2.构造器的名称和类Person一样
    //3.(String pName,int pAge)是构造器形参列表，规则和成员方法一样
    public Person(String pName,int pAge){
        name = pName;
        age = pAge;
    }
}

6.3构造器的相关细节

（1）一个类可以定义多个不同的构造器，即构造器的重载

class Person{
    String name;
    int age;
    //1.构造器没有返回值，也不能写void
    //2.构造器的名称和类Person一样
    //3.(String pName,int pAge)是构造器形参列表，规则和成员方法一样
    public Person(String pName,int pAge){
        name = pName;
        age = pAge;
    }
    public Person(String pName){
        name = pName;
    }
}

在创建对象时，系统会根据你输入的参数调用与之匹配的构造方法

（2）构造器名和类名要相同

（3）构造器没有返回值

（4）构造器是完成对象的初始化，并不是创建对象

（5）在创建对象时，系统自动的调用该类的构造方法

（6）如果程序员没有定义构造方法，系统会自动给类生成一个默认无参构造方法，比如Dog（）{}.

class Dog{
    //如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器
    //可以使用javap指令反编译找到这个构造器，实际情况下是不会显示默认构造器的
    /*
        默认构造器
        Dog(){

        }

     */
}

（7）一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下，即：Person(){}

7.this关键字

7.1this关键字的基本概念

构造方法的输入参数名不是非常的 好，如果能够将dName改成name就好了，但是我们会发现按照变量的作用域原则，name的值就是null，解决方法就是引入this。this代表当前对象。

package grammer;
public class this_grammer {
    public static void main(String[] args){
        Dog dog1 = new Dog("大壮",3);
        dog1.info();
    }
}
class Dog{
    //如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器
    String name;
    int age;
    public Dog(String dName,int dAge){
        name = dName;
        age = dAge; 
    }
/*
    public Dog(String name,int age){
        name = name;结果赋值为null
        age = age;
    }
    这样无法成功赋值需要引入this
*/
    public void info(){//成员方法，输出属性x信息
        System.out.println(name+"\t"+age+"\t");
    }
}

7.2this关键字的基本代码

package grammer;
public class this_grammer {
    public static void main(String[] args){
        Dog dog1 = new Dog("大壮",3);
        dog1.info();
    }
}
class Dog{
    //如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器
    String name;
    int age;
    public Dog(String name,int age){
        //this.name 就是当前对象的属性
        this.name = name;
        //this.age 就是当前对象的属性
        this.age = age;
    }
/*
    public Dog(String name,int age){
        name = name;结果赋值为null
        age = age;
    }
    这样无法成功赋值需要引入this
*/
    public void info(){//成员方法，输出属性x信息
        System.out.println(name+"\t"+age+"\t");
    }
}

7.3this的本质

简单的说，那个对象调用，this就代表哪个对象

7.4this关键字的相关细节

（1）this关键字可以用来访问本类的属性、方法、构造器

（2）this用于区分当前类的属性和局部变量

（3）访问成员方法的语法：this.方法名（参数列表）、

package grammer;
public class ThisDetail {
    public static void main(String[] args){
        T t1 = new T();
        t1.f2();
    }
}
class T{
    //细节：访问成员方法的语法：this.方法名(参数列表);
    public void f1(){
        System.out.println("f1() 方法..");
    }
    public void f2(){
        System.out.println("f2() 方法..");
        //调用本类的f1
        //第一种方法
        f1();
        //第二种方法
        this.f1();
    }
}

（4）访问构造器语法：this（参数列表）；注意只能在构造器中使用（即只能在构造器中访问另外一个构造器）

package grammer;

public class ThisDetail {
    public static void main(String[] args){
        T t1 = new T();
    }
}
class T{
    /*
    细节：访问构造器语法：this(参数列表);
    注意只能在构造器中使用(即只能在构造器中访问另外一个构造器);必须放在第一条语句
     */
    public T(){
        this("jack",100);//this要放在第一句
        System.out.println("T() 构造器");
        //这里访问T(String name,int age)构造器
    }
    public T(String name,int age){
        System.out.println("T(String name,int age) 构造器 ");
    }
}

（5）this不能再类定义的外部使用，只能在类定义的方法中使用