面向对象1

面向对象1

1类结构

/**
 *类结构:1属性 2构造方法 3方法 4块 5内部类
 * 类的声明格式[访问权限修饰符][修饰符或void] class 类名{     }
 * 访问权限修饰符:public或default(不写)
 * 修饰符:final abstract
 * 方法声明:[访问权限修饰符][修饰符或void] 返回值类型 方法名(参数类型 参数名称){  [return]  }
 * 注:类本质是:一个.java文件
 */
public class Dog {
    //属性

    //成员变量
    String name;//默认值null
    String color;
    String type;
    float price;//默认值0.0
    char sex;//默认值空
    int age;//默认值0
    double child;//默认值0.0
    boolean b;//默认值false
    byte e;//默认值0
    short s;//默认值0

    /**
     * 方法:吃
     */
    public void eat(String food){
        //局部变量
        int speed;
        System.out.println("狗要吃"+food);
        System.out.println("狗需要吃");
    }
    /**
     * 方法:叫
     */
    public void shout(String person){
        System.out.println("旺旺旺旺...");
    }
    //内部类
    //代码块
}

2对象的创建-使用

/**
 * 创建对象:
 * 1   new关键 + 以某个类为模板的默认构造方法   new Dog( )  存在于内存中
 * 2   声明一个变量(dog),指向对象;
 * 3   对象是Dog类型的,所以声明的变量也为Dog类型    Dog dog = new Dog( )
 * 4   通过变量能访问对象的 属性 方法
 */
public class TestDog {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        //访问对象的属性,并给其赋值
        dog1.name = "哈士奇";
        //调用属性
        System.out.println(dog1.name);
        /*System.out.println(dog1.sex);
        System.out.println(dog1.age);
        System.out.println(dog1.child);
        System.out.println(dog1.b);
        System.out.println(dog1.s);
        System.out.println(dog1.e);*/
        //访问对象的方法
        dog1.shout("");
        dog1.eat("肉");


        Dog dog2 = new Dog();
        //访问对象的属性,并给其赋值
        dog2.name = "哈哈奇";
        //调用属性
        System.out.println(dog2.name);
        //访问对象的方法
        dog1.shout("");
    }
}

3变量分类

1成员变量

:定义在类中,方法体之外

:可使用的数据类型:基本数据类型\引用数据类型

:可赋值;不赋值时Java会自动给其默认值

2局部变量

    
public class Person {
    //成员变量
    int age;
    String name;//默认值null
    String color;
    String type;
    float price;//默认值0.0
    char sex;//默认值空
    int age;//默认值0
    double child;//默认值0.0
    boolean b;//默认值false
    byte e;//默认值0
    short s;//默认值0
}
public void read(String nam,int a//局部变量){
        age = a;
        name = nam;
        System.out.println("阅读");
    }

4方法分类

1成员方法

2构造方法\调用构造方法

3类方法(静态方法)

/**
 * 构造方法
 * 方法名与类名相同
 * 声明:new + 构造方法
 */
public class Person {
    //成员变量
    String name;
    int age;
    //构造方法
    public Person(){
        System.out.println("默认无参构造方法");
    }
    public Person(String n,int a){//有一个有参构造方法时,默认无参的就会失效
        name = n;
        age = a;
        System.out.println("有参构造方法");
    }

    //成员方法
    public void read(String nam,int a){
        age = a;
        name = nam;
        System.out.println("阅读");
    }
    public void study(int a,String nam){
        age = a;
        name = nam;
        System.out.println(age);
        System.out.println(name);
        System.out.println("学习");
    }

}
public class TestPerson {
    public static void main(String[] args) {
        /*new Person();//调用无参构造方法
        new Person("jim");//调用有参构造方法*/

        //调用构造方法时的两种赋值(创建对象\赋值;   创建对象的同时赋值)
        Person p1 = new Person();
        p1.name = "Jim";
        p1.age = 3;
        System.out.println(p1.name);
        System.out.println(p1.age);

        Person p2 = new Person("Tom",3);
        System.out.println(p2.name);
        System.out.println(p2.age);

        Person p0 = new Person();
        //调用成员方法
        p0.study(18,"jim");
        p0.read("jim",18);

    }
}

5方法重载

/**
 * 方法重载
 * 发生情况:同一个类中 有 (多个)方法名相同   参数不同 的方法
 * 参数不同包括:个数\类型\顺序不同
 */
public class Person {
    //成员方法(演示重载)
    public void eat(String name){
        System.out.println("吃饭1");
    }
    public void eat(int num){
        System.out.println("吃饭2");
    }
    public void eat(String name,int num){
        System.out.println("吃饭3");
    }
    public void eat(int num,String name){
        System.out.println("吃饭4");
    }
}
public class TestPerson {
    public static void main(String[] args) {
        Person p0 = new Person();
        //重载测试
        p0.eat(2);
        p0.eat("coco");
        p0.eat("coco",3);
        p0.eat(4,"coco");

    }
}