类与对象

每篇一题答案

public class Test {
    public static void main(String[] args) {
        String s1 = "runoob";
        String s2 = "runoob";
        System.out.println("s1 == s2 is:" + s1 == s2);
    }
}

答案:>false
这道题表面上在考引用与对象的关系，即当指向同一个对象的引用变量其存储的内容是该对象的地址；
但是，题目本质上却是在考运算的的优先级问题，在本题中“+”的运算优先级比“==”的优先级要高，所以不是s1和s2进行比较，而是“s1 == s2 is : runoob”这个字符串和s2进行比较，其结果当然是false；

类与对象

类和对象的关系

类是Java中的重要知识点，学过C语言的同学都知道结构体，与之比较，类就是一个高配的结构体；
类中有成员变量，方法体；而对象则是自定义类型创造出来的变量；
类和对象的关系是什么，如果说类是类型的话，那么对象就是这个类型的一个具体的个体。例如类型是人（Person），那么对象就具体到什么人，男人、女人等等；可以将类比喻成图纸，而对象就是用这张图纸所建造的一栋栋房子。

类的创建及使用

类的创建格式：

class 类名{
}

需要注意的是，public修饰的类名一定要和java文件的名字一样，否则就会编译出错；
在类里面创建的变量是成员变量，作用域为整个类，在方法里面的变量为局部变量；

public class  Cat {
    //属性/成员变量
    public String name = "咪咪";
    public String sex = "公猫";
    //方法/成员函数
    public void doing(){
        System.out.println(name + "在睡觉！" );
    }
}

光光创建这样一个类是无法出现任何结果的，我们需要将这个类实例化，也就是用这个类创建对象，来实现这个类中的代码；

public class Oper_2 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.doing();
    }
}

使用类名创建一个对象（实例化），然后通过操作符 “. ” 来访问类中的方法和成员变量；

注意事项：

• new 关键字用于创建一个对象的实例.
• 使用 “.” 来访问对象中的属性和方法.
• 同一个类可以创建对个实例.

属性初始化及构造方法

Java中对于对象的初始化方式有很多种：
1、默认值，类中的默认初始值，String类型为null，int类型为0，char为空，boolean为false；
2、就地初始化，即在定义成员变量的时候就初始化；
3、使用代码块初始化，即在类中出一个大括号，大括号中的代码就会在 new 对象的时候自动执行；
4、构造方法初始化：构造方法是一种特出的方法

1. 构造方法的方法名是固定的，必须和类名相同；
2. 构造方法不需要 return 语句，但是可以理解成返回了该对象的引用.
3. 构造方法不需要显示调用，而是在 new 的时候自动被调用
4. 构造方法也支持重载，重载规则和普通方法一样；

主要来介绍一下使用构造方法来初始化，构造方法分为有参数和无参数；
无参数构造方法是直接将成员变量直接赋值；

public class  Cat {
    public String name ;
    public String sex ;
    public int age ;
   //无参数构造方法
    public Cat(){
        name = "咪咪";
        sex = "公猫";
        age = 3;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
----------------------------------------------------------
public class Oper_2 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println(cat.toString());
    }
}

Cat{name='咪咪', sex='公猫', age=3}

这是无参数构造方法，但是无参数构造方法只能让有一只猫的名字或者很多猫都加“咪咪”，如果我想要很多只猫怎么办，这个时候就要使用有参数的构造方法；

public class  Cat {
    public String name ;
    public String sex ;
    public int age ;
    //有参数的构造方法
    public Cat(String name, String sex, int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}
-------------------------------------------------------
public class Oper_2 {
    public static void main(String[] args) {
        Cat cat1 = new Cat("咪咪", "公猫", 3);
        Cat cat2 = new Cat("咔咔", "母猫", 2);
        System.out.println(cat1.toString());
        System.out.println(cat2.toString());
    }
}

Cat{name='咪咪', sex='公猫', age=3}
Cat{name='咔咔', sex='母猫', age=2}

在有参数的构造方法中涉及到一个关键字：this，那么我们在使用这个关键字的时候需要注意以下几点：
1、this是指向当前对象的引用
2、this的类型是当前这个类的类型
3、this的指向不能被修改
4、this也可以用来调用方法
5、this不能是null

static关键字

static关键字是面向对象中常用的关键字之一，如果类中的某个成员加上了 static，说明这个成员是一个类属性/类方法；如果没有static，成员是一个 实例属性/实例方法.
静态方法中不能使用this，this指向的是当前的实例，static 方法和实例无关，只和类有关；
在主方法中用实例化的实例来访问静态变量或者静态方法是会报错的，static修饰的成员变量和方法是类中的，与实例无关，所以需要用类名调用；

public class  Cat {
    public String name ;
    public String sex ;
    public int age ;
    public static String nickName = "小花";

    public Cat(String name, String sex, int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public static void doing(){
        System.out.println(nickName + "在睡觉");
    }
}
-----------------------------------------------------
public class Oper_2 {
    public static void main(String[] args) {
        Cat cat1 = new Cat("咪咪", "公猫", 3);
        Cat cat2 = new Cat("咔咔", "母猫", 2);
        System.out.println(Cat.nickName);
        Cat.doing();
    }
}

static 创建的代码块称为静态代码块，其只在类加载的时候执行一次，就算在实例化几次也只执行一次；往往用来初始化静态成员.

访问限定符（重要）

Java有“三大特性”——封装，继承，多态
封装是管理代码复杂度的核心手段，其目的就是为了让使用者了解到的信息尽量的少；而封装就是通过访问限定符来实现的；
由于所学知识有限，我在这里介绍两种最常见的即可（原有四种）——public、private；
public是比较常见的的，用public修饰的变量和方法可以被外部的类随意访问，不会受到限制，即使用者可以掌握到、观察到的信息；
private译为私有的，其修饰的变量和方法只能在自己的类中的访问，拒绝其他类的访问，它可以在一定程度上保护代码的安全性，不让人随意修改；
如果在别的类中需要使用private修饰的变量和方法，可以在该变量（方法）所在的类中创建一个public修饰的方法来使用或调用成员变量，外部类通过调用这个public的方法来使用private的变量、方法.
原则上在Java创建自定义类的时候，成员变量/方法能用private修饰就用private修饰.

public class  Cat {
    private String name ;
    private String sex ;
    private int age ;

    public Cat(String name, String sex, int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    private void eat(String food){
        System.out.println(name + "吃" + food);
    }
    public void doing(){
        eat("fish");
        System.out.println(name + "在睡觉");
    }
}
--------------------------------------------------------
public class Oper_2 {
    public static void main(String[] args) {
        Cat cat = new Cat("咪咪", "公猫", 3);
        cat.doing();
    }
}

咪咪吃fish
咪咪在睡觉

每篇一题

Oper_2.java

public class Oper_2 {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        Cat cat2 = new Cat();
    }
}

Cat.java

public class Cat {
    public String name = "咪咪";
    static String name1 = "咔咔";
    static{
        System.out.println(name1 + "在吃饭");
    }
    {
        System.out.println(name + "在吃饭");
    }
}

请问输出的结果是什么？