4.类与对象

类与对象

1.类

例:创建一个猫类，里面有若干属性

class cat {  //创建了一个名为cat的类
    //属性
    String name;
    int age;
    String color;
}
public static void main(String []args){
    //使用面向对象实例化一只猫
    cat c1 = new cat();
    //new cat() 创建一只猫，赋给c1,c1就是一个对象
    c1.name = "小白";
    c1.age = "1";
    c1.color = "白色";
    cat c2 = new cat();//创建了第二只猫
    System.out.println(c1.name+c.age+c1.color)
    //访问对象的属性
}

2.属性/成员变量

定义:属性是类的一个组成部分，一般是基本的数据类型也可以是引用类型(数组、对象)，比如上例中的int age 就是一个属性
注意:new cat()创建的是对象空间(数据)才真的是对象

3.创建对象的形式

1.先声明再创建
cat c1;
c1 = new cat();
2.直接创建
cat c1 = new cat();
3.如何访问属性
对象名.属性名
例:cat.name
……

4.成员方法(方法)

例:有person类,里面有2个属性,有一个方法。

class person{
    int age;
    String name;
    public void speak(){   //speak方法,有void代表没有返回值,public表示方法是公开的。
        System.out.println("我是新手");
    }
    public void sum(int n){   //int n 为形参
        int res = 0;
        for(int i = 0;i <= n;i++){
            res = res + i;
        }
    }
    public summ(int sum1,int sum2){
        int res = sum1+sum2;
        return res;       //有返回值(return),为res,没有void。
    }
public static void main(Strint[]args){
    person p1 = new person();
    p1.speak();//调用方法
    p1.sum(5);//调用方法,并将5(实参)传递给sum的形参(n)接收
    int reset = p1.summ(5,10);//调用summ方法，传参，因为有返回值，所以用reset变量接收。
    System.out.println(reset);
    
}
}

方法的好处:
1.提高了代码的复用性
2.可以将细节封装起来，然后供其他用户来调用使用
方法注意事项:
1.一个方法最多只能有一个返回值
2.如果方法要求有返回值类型，则方法体中最后执行的语句必须为return 值;而且要求返回值类型必须和return的值类型一致或兼容
方法的传参机制:
1.基本数据类型,传递的是值(值拷贝),形参的任何改变不会影响实参；
2.引用类型传递的是地址(传递也是值,但值是地址),可以通过形参来影响实参；

5.方法的递归

个人理解:在方法中重复的调用方法
例:

public static void main(String[]args){
    T t1 = new T();
    t1.test(4);
}
class T{
public void test(int n){
    if(n>2){
        test(n-1);
    }
    System.out.println("n=" + n);
    }
}

上面的案例输出的结果为:
n = 2
n = 3
n = 4
例2:用递归求阶乘

public int factorial(int n){
    if(n == 1){
        return 1;
    }else{
        factorial(n-1)*n;
    }
}

递归注意事项:
1.执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
2.方法的局部变量是独立的，不会相互影响，比如n变量
3.如果方法使用的是运用类型变量，就会共享该引用类型
4.当一个方法执行完毕，或者遇到了return，就会返回，遵守谁调用，结果就返回给谁

6.方法重载

1.java中允许同一个类多个同名的方法,但是必须参数不同。
例:

public class test{
    public static void main(String[]args){
        MyCalculator mc = new MyCalculator();
        System.out.println(mc.Calculator(1,2));
        System.out.println(mc.Calculator(1,2.8));
        System.out.println(mc.Calculator(1,2.1,11));
    }
}
class MyCalculator{   //类
    public int calculator(int n1,int n2){   //方法
        return n1+n2;
    }
    public double calculator(int n1,double n2){   //构造方法1(数据类型不一样)
        return n1+n2;
    }
    public public calculator(int n1,double n2,int n3){   //构造方法2(数据个数不一样)
        return n1+n2+n3;
    }
}

7.可变参数

例:

class m{
    public int sum(int n,int x){
        return n+x;
    }
    public int sum(int n,int x,int y){
        return n+x+y;
    }
    ......
    //上面的三个方法名称相同，功能相同，参数个数不同--->可使用可变参数优化
}

可改写为:

//1.int...可以表示接受的是可变参数，类型是int,即可以接收多个int(0-多)
//2.使用可变参数时，可以当做数组来使用，即n可以当做数组
//3.遍历n求和即可
class Method{
public int m(int... n){
    int res = 0;
    for(int i = 0;i< n.length;i++>){
        res = res+n[i]
    }
    return res;
    }
}
public static void main(String[]args){
    Method m1 = new Method();
    System.out.println(m1.m(1,5,100));
}

注意细节:
1.可变参数的实参可以为0或任意多个。
2.可变参数的实参可以是数组。
3.可变参数的本质就是数组。
4.可变参数可以和普通类型的参数放在一起，但必须保证可变参数在最后
5.一个形参列表中只能出现一个可变参数。

8.作用域

注意事项:
1.属性和局部变量可以重名，访问时遵循就近原则;
2.在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名;
3.属性生命周期较长，对象无，则属性无;局部变量，生命周期短，代码块结束，局部变量无;
4.作用域范围不同
全局变量:可以被本类使用，或其他类使用(通过对象调用)
局部变量:只能在本类中对应的方法中使用
5.修饰符不同
全局变量/属性可以加修饰符
局部变量不可以加修饰符

9.构造方法

语法:
[修饰符]方法名(形参列表){
方法体;
}
作用:完成对新对象的初始化
说明:
1.构造器的修饰符可以默认，也可以是public private
2.构造器没有返回值
3.方法名和类名一样
4.参数列表和成员方法一样的规则
5.构造器的调用系统完成
通过this调用其他的构造方法:
例子:

public class test {
    String name;
    int age;
    public test(String name) {
        this.name = name;
    }
    public test(String name,int age) {
        this(name);
        this.age = age;
    }
    public static void main(String[] args) {
        test person = new test("man",22);
        System.out.println(person.name);
    }
}

例:

class Person{
    String name;
    int age;
    public Person(String pname,int page){//构造器/构造方法
        name = pname;
        age = page;
    }
}

注意:
1.如果程序员没有定义构造方法，系统会自动给类生成一个无参构造方法，可以用javap反编译。
2.一旦定义了自己的构造器，则默认构造器就覆盖了

10.this关键字

java虚拟机会给每个对象分配this,代表当前对象
例:

public Dog(String name,int age){
    this.name=name;
    this.age=age;
    //this.name就是当前对象的属性name
    //this.age就是当前对象的属性age
}

简单地说:哪个对象调用,this就代表了哪个对象
注意事项:
1.this关键字可以用来访问本类的属性、方法、构造方法
2.this用于区分当前类的属性和局部变量
3.访问成员方法的语法:this.方法名(参数列表);
4.this可以出现在实例方法和构造方法中,但不可以出现在类方法中
例:

public static void main(String []args){
    T t1 = new T();
    t1.f2();
}
class T{
    public void f1(){
        System.out.println("f1()方法..");
    }
    public void f2(){
        System.out.println("f2()方法..");
        f1();
        this.f1();
    }
}
//输出为:
//f2()方法..
//f1()方法..
//f1()方法..

4.访问构造器语法:this(参数列表);只能在构造方法里使用(即只能在构造器中访问另外一个构造器,必须放在第一条语句)
例:

public static void main(String []args){
    T t2 = new T();
}
class T{
    public T(){
        this("haozi",100);
        System.out.println("T()构造器")
    }
    public T(String name,int age){
        System.out.println("T(String name,int age)构造器")
    }
}
//输出结果为:
//T(String name,int age)构造器
//T()构造器