类和对象的应用

面向对象和面向过程的区别：

对象是由类产生的。

类：抽象，类似于图纸

对象：实体，类似于由图纸实例化出来的对象。通过new实例化

class Person{//由class关键字定义了一个Person类型
    //属性\成员变量（普通成员变量、静态成员变量）
    //方法\成员方法（普通成员方法、静态成员方法）
    public String name;//普通成员变量
    public static int a;//静态成员变量
    public void sleep(){//普通成员方法
        System.out.println(name+"睡觉");
    }
    public static void func(){//静态成员方法
        System.out.println("静态方法");
    }
}


public class TestDemo {

    
    //调用静态成员变量和方法
    public static void main(String[] args) {
        Person.func();
        System.out.println(Person.a);
    }


    //调用普通成员变量和方法
    public static void main2(String[] args) {
        Person person = new Person();//实例化一个对象
        person.name = "123";
        person.sleep();
    }



    public static void main1(String[] args) {
        Person person = null;//person不指向任何对象
        //引用变量不一定在栈上
        //引用指向另一个引用所指的对象
        //引用不能指向多个对象
    }

普通成员方法中不能定义静态成员变量

在静态成员方法中也不能调用普通成员变量

定义一个猫类：

class Cat{
    public String name;
    public int age;
    public String sex;
    public void eat(){
        System.out.println(name+"吃饭");
    }
    public void sleep(){
        System.out.println(name+"睡觉");
    }
    public void jump(){
        System.out.println(name+"跳");
    }

}




public class TestDemo {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        cat1.name = "咪咪";
        cat1.sex = "女";
        cat1.age = 1;
        cat1.eat();
        cat1.sleep();
        cat1.jump();
        System.out.println("============");
        Cat cat2 = new Cat();
        cat2.name = "哈哈";
        cat2.sex = "男";
        cat2.age = 2;
        cat2.eat();
        cat2.sleep();
        cat2.jump();
    }



}

运行结果：

咪咪吃饭
咪咪睡觉
咪咪跳
============
哈哈吃饭
哈哈睡觉
哈哈跳

封装：(private)

public  private  访问权限修饰限定符

语法层次：字段和方法都被private修饰，此时就说把这个字段或者这个方法进行了封装。

封装的意义：1.更安全；2.降低了对类的使用成本

被private修饰的字段和方法只能在当前类当中使用，不能在类外使用。如果被封装后想在其他类中使用，则需提供一个公开的set和get方法

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

    public void setName(String myName){
        name = myName;
    }


    public String getName(){
        return name;          //返回name
    }


    public void eat(){
        System.out.println(name+"吃饭");
    }
}


public class TestDemo {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        System.out.println(cat1.getName());//打印出“咪咪”
        cat1.setName("咪咪") ;
        cat1.sex = "女";
        cat1.age = 1;
        cat1.eat();
}

构造方法： 

//构造方法：没有返回值，方法名称和类名是一样的
class Student{
    public Student(){
        System.out.println("不带有参数的构造方法");
    }
}




public class TestDemo {

    public static void main(String[] args) {
        Student student = new Student();
    }//new Student()中的Student()调用了不带参数的构造方法


运行结果：
不带有参数的构造方法

 当没有写构造方法时，编译器会默认生成一个不带参数的构造方法

//构造方法：没有返回值，方法名称和类名是一样的
class Student{
    private String name;
    private int age;
    public Student(String name){
        this.name = name;//this指当前对象的引用
        System.out.println("带有1个参数的构造方法");
    }
    public Student(){
        System.out.println("不带有参数的构造方法");
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("带有2个参数的构造方法");
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}



public class TestDemo {

    public static void main(String[] args) {
        Student student = new Student("bit");
        System.out.println(student);

        Student student2 = new Student("bit",10);
        System.out.println(student2);
    }

运行结果：

带有1个参数的构造方法
Student{name='bit', age=0}
带有2个参数的构造方法
Student{name='bit', age=10}

this三种使用方式：

1.调用属性

2.调用方法

3.调用构造方法

this()只能调用一次方法，并且只能放在构造方法第一行当中