面向对象（二）

来源：互联网发布：ug8.5编程加工实战视频编辑：程序博客网时间：2024/05/17 01:46

成员变量和局部变量的区别

    A:在类中的位置不同        成员变量：在类中方法外        局部变量：在方法定义中或者方法声明上    B:在内存中的位置不同        成员变量：在堆内存        局部变量：在栈内存    C:生命周期不同        成员变量：随着对象的创建而存在，随着对象的消失而消失        局部变量：随着方法的调用而存在，随着方法的调用完毕而消失    D:初始化值不同        成员变量：有默认初始化值        局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。    注意事项：        局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

class Varialbe {    //成员变量    //int num = 10;    int num; //0    public void show() {        //int num2 = 20; //局部变量        //可能尚未初始化变量num2        //int num2; //没有默认值        int num2 = 20;        System.out.println(num2);        //int num = 100;        System.out.println(num);    }}class VariableDemo {    public static void main(String[] args) {        Varialbe v = new Varialbe();        System.out.println(v.num); //访问成员变量        v.show();       }}

形式参数的问题

    基本类型：形式参数的改变不影响实际参数    引用类型：形式参数的改变直接影响实际参数

//形式参数是基本类型class Demo {    public int sum(int a,int b) {        return a + b;    }}//形式参数是引用类型class Student {    public void show() {        System.out.println("我爱学习");    }}class StudentDemo {    //如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。    public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();        s.show();    }}class ArgsTest {    public static void main(String[] args) {        //形式参数是基本类型的调用        Demo d = new Demo();        int result = d.sum(10,20);        System.out.println("result:"+result);        System.out.println("--------------");        //形式参数是引用类型的调用        //需求：我要调用StudentDemo类中的method()方法        StudentDemo sd = new StudentDemo();        //创建学生对象        Student s = new Student();        sd.method(s); //把s的地址给到了这里    }}

匿名对象

    就是没有名字的对象。匿名对象的应用场景：    A:调用方法，仅仅只调用一次的时候。        注意：调用多次的时候，不适合。        那么，这种匿名调用有什么好处吗?            有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。    B:匿名对象可以作为实际参数传递

class Student {    public void show() {        System.out.println("我爱学习");    }}class StudentDemo {    public void method(Student s) {        s.show();    }}class NoNameDemo {    public static void main(String[] args) {        //带名字的调用        Student s = new Student();        s.show();        s.show();        System.out.println("--------------");        //匿名对象        //new Student();        //匿名对象调用方法        new Student().show();        new Student().show(); //这里其实是重新创建了一个新的对象        System.out.println("--------------");        //匿名对象作为实际参数传递        StudentDemo sd = new StudentDemo();        //Student ss = new Student();        //sd.method(ss); //这里的s是一个实际参数        //匿名对象        sd.method(new Student());        //在来一个        new StudentDemo().method(new Student());    }}

封装和private关键字

private:    是一个权限修饰符    可以修饰成员变量和成员方法    被其修饰的成员只能在本类中被访问

class Demo {    //int num = 10;    //用private修饰    private int num = 10;    public void show() {        System.out.println(num);    }    private void method() {        System.out.println("method");    }    public void function() {        method();    }}class PrivateDemo {    public static void main(String[] args) {        Demo d = new Demo();        //不能方法私有的成员变量        //System.out.println(d.num);        d.show();        //不能访问私有的成员方法        //d.method();        d.function();    }}

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

class Student {    //姓名    String name;    //年龄    private int age;    //写一个方法对数据进行校验    /*        返回值类型：void        参数列表：int a    */    public void setAge(int a) {        if(a < 0 || age > 120) {            System.out.println("你给的年龄有问题");        }else {            age = a;        }    }    //show()方法,显示所有成员变量值    public void show() {        System.out.println("姓名："+name);        System.out.println("年龄："+age);    }}class StudentDemo {    public static void main(String[] args) {        //创建学生对象        Student s = new Student();        s.show();        System.out.println("--------------");        //给成员变量赋值        s.name = "林青霞";        //s.age = 27;        s.setAge(27);        s.show();        System.out.println("--------------");        //给age赋值        //s.age = -27; //这个数据是不合理的        //通过方法给值        s.setAge(-27);        s.show();        System.out.println("--------------");    }}

this关键字

this:哪个对象调用那个方法，this就代表那个对象

class Student {    private String name;    private int age;    public String getName() {        return name; //这里其实是隐含了this    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}class StudentTest2 {    public static void main(String[] args) {        //创建一个对象        Student s1 = new Student();        s1.setName("林青霞");        s1.setAge(27);        System.out.println(s1.getName()+"---"+s1.getAge());        //创建第二个对象        Student s2 = new Student();        s2.setName("刘意");        s2.setAge(30);        System.out.println(s2.getName()+"---"+s2.getAge());    }}

this内存图

构造方法

    给对象的数据进行初始化格式：    A:方法名与类名相同    B:没有返回值类型，连void都没有    C:没有具体的返回值

class Student {    private String name; //null    private int age; //0    public Student() {        System.out.println("这是构造方法");    }}class ConstructDemo {    public static void main(String[] args) {        //创建对象        Student s = new Student();        System.out.println(s); //Student@e5bbd6    }}

我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?构造方法的注意事项:    A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。    B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。        注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法给成员变量赋值有两种方式：    A:setXxx()    B:构造方法

class Student {    private String name;    private int age;    public Student() {        //System.out.println("我给了，你还给不");        System.out.println("这是无参构造方法");    }    //构造方法的重载格式    public Student(String name) {        System.out.println("这是带一个String类型的构造方法");        this.name = name;    }    public Student(int age) {        System.out.println("这是带一个int类型的构造方法");        this.age = age;    }    public Student(String name,int age) {        System.out.println("这是一个带多个参数的构造方法");        this.name = name;        this.age = age;    }    public void show() {        System.out.println(name+"---"+age);    }}class ConstructDemo2 {    public static void main(String[] args) {        //创建对象        Student s = new Student();        s.show();        System.out.println("-------------");        //创建对象2        Student s2 = new Student("林青霞");        s2.show();        System.out.println("-------------");        //创建对象3        Student s3 = new Student(27);        s3.show();        System.out.println("-------------");        //创建对象4        Student s4 = new Student("林青霞",27);        s4.show();    }}

类的组成

类的组成：    A: 成员变量    B: 构造方法    C: 成员方法        根据返回值：            void类型            非void类型        形式参数：            空参方法            非空参方法

创建对象做了哪些事情

main方法格式讲解

main方法的格式讲解：    public static void main(String[] args) {...}    public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。    static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。    void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。    main:是一个常见的方法入口。我见过的语言都是以main作为入口。    String[] args:这是一个字符串数组。值去哪里了?        这个东西到底有什么用啊?怎么给值啊?            这个东西早期是为了接收键盘录入的数据的。            格式是：                java MainDemo hello world java

static关键字

static的特点：(它可以修饰成员变量，还可以修饰成员方法)        A:随着类的加载而加载            回想main方法。        B:优先于对象存在        C:被类的所有对象共享            举例：咱们班级的学生应该共用同一个班级编号。            其实这个特点也是在告诉我们什么时候使用静态?                如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。            举例：                饮水机(用静态修饰)                水杯(不能用静态修饰)        D:可以通过类名调用            其实它本身也可以通过对象名调用。            推荐使用类名调用。        静态修饰的内容一般我们称其为：与类相关的，类成员

class Student {    //非静态变量    int num = 10;    //静态变量    static int num2 = 20;}class StudentDemo {    public static void main(String[] args) {        Student s = new Student();        System.out.println(s.num);        System.out.println(Student.num2);        System.out.println(s.num2);    }}

注意事项

static关键字注意事项        A:在静态方法中是没有this关键字的            如何理解呢?                静态是随着类的加载而加载，this是随着对象的创建而存在。                静态比对象先存在。        B:静态方法只能访问静态的成员变量和静态的成员方法                静态方法：                    成员变量：只能访问静态变量                    成员方法：只能访问静态成员方法                非静态方法：                    成员变量：可以是静态的，也可以是非静态的                    成员方法：可是是静态的成员方法，也可以是非静态的成员方法。            简单记：                静态只能访问静态。

class Teacher {    public int num = 10;    public static int num2 = 20;    public void show() {        System.out.println(num); //隐含的告诉你访问的是成员变量        System.out.println(this.num); //明确的告诉你访问的是成员变量        System.out.println(num2);        //function();        //function2();    }    public static void method() {        //无法从静态上下文中引用非静态 变量 num        //System.out.println(num);        System.out.println(num2);        //无法从静态上下文中引用非静态 方法 function()        //function();        function2();    }    public void function() {    }    public static void function2() {    }}class TeacherDemo {    public static void main(String[] args) {        //创建对象        Teacher t = new Teacher();        t.show();        System.out.println("------------");        t.method();    }}

0 0