LY.JAVA面向对象编程.封装、this、构造方法

2018-07-07

this关键字

构造方法

 /*
     我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?

     构造方法的注意事项:
         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();
     }
 }

一个标准代码的终极版

 /*
     一个标准代码的最终版。

     学生类：
         成员变量：
             name，age
         构造方法：
             无参，带两个参
         成员方法：
             getXxx()/setXxx()
             show()：输出该类的所有成员变量值

     给成员变量赋值：
         A:setXxx()方法
         B:构造方法

     输出成员变量值的方式：
         A:通过getXxx()分别获取然后拼接
         B:通过调用show()方法搞定
 */
 class Student {
     //姓名
     private String name;
     //年龄
     private int age;

     //构造方法
     public Student() {
     }

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

     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;
     }

     //输出所有的成员变量值
     public void show() {
         System.out.println(name+"---"+age);
     }
 }

 //测试类
 class StudentTest {
     public static void main(String[] args) {
         //方式1给成员变量赋值
         //无参构造+setXxx()
         Student s1 = new Student();
         s1.setName("林青霞");
         s1.setAge(27);
         //输出值
         System.out.println(s1.getName()+"---"+s1.getAge());
         s1.show();
         System.out.println("----------------------------");

         //方式2给成员变量赋值
         Student s2 = new Student("刘意",30);
         System.out.println(s2.getName()+"---"+s2.getAge());
         s2.show();
     }
 }

注意：import必须放在所有的class文件前面

Static关键字

内存图

 /*
     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();
     }
 }

public static void main(String[] args){ ...}

详细解释

 /*
     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
 */
 class MainDemo {
     public static void main(String[] args) {
         //System.out.println(args); //[Ljava.lang.String;@175078b
         //System.out.println(args.length); //0
         //System.out.println(args[0]); //ArrayIndexOutOfBoundsException

         //接收数据后
         System.out.println(args);
         System.out.println(args.length);
         //System.out.println(args[0]);
         for(int x=0; x<args.length; x++) {
             System.out.println(args[x]);
         }
     }
 }