day10--Java面向对象--Javaobject01-3&javaobject02

今天我们主要学习了如下内容：

1. 代码块(局部代码块，构造代码块，静态代码块)
2. package和import关键字
3. 了解面向对象思想
4. 访问权限
5. 面向对象3大特征之封装

 1.补充昨天的，Static关键字：

package com.cskaoyan.syntax.yesterday.keyStatic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 *  对于： 静态上下文 不能访问非静态的成员变量和非静态的成员方法的补充说明
 *       a. 在静态方法中，不能访问的非静态的成员变量和非静态的成员方法(this的)
 *       b. 在静态方法中，对于非this的普通成员变量和普通成员方法，可以访问的
 *
 */
public class Demo1 {

  public static void main(String[] args) {
    //StaticClass.testStatic();
  }

}

class StaticClass {
  int i;


  public static void testStatic(StaticClass obj) {
     // 静态上下文 不能访问(this当前对象)非静态的成员变量和非静态的成员方法
    //System.out.println(this.i);
    //this.method();

    // 我们在静态方法中，在我们创建的对象上，访问其普通成员变量和普通成员方法，都可以访问
    //StaticClass staticClass = new StaticClass();
    //System.out.println(staticClass.i);
    //staticClass.method();

    System.out.println(obj.i);
    obj.method();

  }


  public void method() {

  }


}

 

2.代码块：

package com.cskaoyan.syntax.codeblock;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 * 代码块
      1. 在Java中，使用{}括起来的代码被称为代码块
      2. 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)


   局部代码块(开发中，不会用)：
    1. 声明位置：定义在 方法体 中的用{}括起来的一段代码
    2. 执行时机：随着方法的执行而执行
    优点：限定变量生命周期，及早释放，提高内存利用率
        (这个优点理论上确实存在，但是这个优点，在现在jvm中其效果，微乎其微的，甚至可以忽略不计)
        我们在开发中，同时还要追求，代码可维护性(包括代码的可读性)

     在嵌套的代码块中，不能定义同名变量

    构造代码块:
    1. 声明的位置, 类中，方法体之外{}包含的代码
    2. 执行特征： 创建对象的时候执行, 而且每次创建对象的时候必执行
       构造方法和构造代码块，都是在创建对象的时候执行，有没有先后顺序呢？
       构造代码块先执行，构造方法后执行

    构造代码块的使用场景：
          1. 可以把多个构造方法方法中相同的，提取朱来放到构造代码块中，每次调用构造都执行，并且在构造方法前执行
          2. 我们也可以用，构造代码块，来初始化对象的成员变量的值

     成员变量初始化语句 和 构造代码块他们的执行先后顺序是： 按照代码的书写先后顺序顺序

    关于成员变量 初始化语句，构造代码块中的赋值语句，以及构造方法中的赋值(都是对成员变量的赋值)，有如下结论：
    1. 不管是成员变量的初始化语句，还是构造代码块中的赋值语句，它们都先于构造方法的赋值执行
    2. 初始化语句和构造代码块中的赋值语句，执行的先后顺序和代码书写顺序有关，谁在前谁就先执行

   静态代码块：
    1. 声明位置：类中方法体之外，除此之外，还被static修饰
    2. 执行特征：静态代码块，随着类加载而执行，所以，静态代码块，它的执行还有一个特征，至多执行一次

    注意事项：
       a. 在学习了静态代码块之后，静态上下文，就多了一个，静态代码块
 */
public class Demo1 {

  public static void main(String[] args) {

    // 可以在主方法中，创建一个对象，然后在该对象上调动，其非静态成员方法
    //CodeBlockClass obj = new CodeBlockClass();
    // 运行方法的局部代码块
    //obj.testLocalBlock();

    //CodeBlockClass obj1 = new CodeBlockClass(1);
    //CodeBlockClass obj2 = new CodeBlockClass(1, 2);

    // 测试 成员变量的初始化语句和构造构造代码块中的成员变量的赋值语句，谁先执行，谁后执行？
    //System.out.println(obj.i);

    // 在不创建对象的情况下，我们可以通过访问类中的静态变量或者静态方法，来触发类加载
    System.out.println(CodeBlockClass.staticInt);
    //System.out.println(CodeBlockClass.staticInt);
  }

  public void test() {

  }
}

class CodeBlockClass {
  int j;

  /*
      假设，我有这样一个功能要实现：我希望有一段代码，不管在创建对象时，
      用的是哪个构造方法，来初始化对象初值，我都希望这段代码一定执行
   */
  public CodeBlockClass() {
    //System.out.println("构造方法执行了");
    // 必执行的一端代码
    //System.out.println("必执行的一端代码CodeBlockClass()");

    this.i = 20;
  }
  public CodeBlockClass(int i) {
    this.i = i;
    // 必执行的一端代码
    //System.out.println("必执行的一端代码CodeBlockClass(int i)");
  }
  public CodeBlockClass(int i, int j) {
    this.i = i;
    this.j = j;
    // 必执行的一端代码
    //System.out.println("必执行的一端代码 CodeBlockClass(int i, int j)");
  }
  // 成员变量的初始化语句
  int i = 100;

  /*
          构造代码块, 中的代码，可以访问当前对象的成员变量
   */
  {
    //System.out.println("构造代码块执行了");
    //System.out.println("必执行的代码");
    this.i = 10;
    System.out.println(i);
  }


  static int staticInt = 100;

  /*
      静态代码块, 也是静态上下文的一种
   */
  static {
    // 静态上下文不能访问非静态的成员变量或非静态的成员方法(this的)
    //System.out.println(this.j);

    //访问静态成员变量
    //System.out.println(staticInt);

    staticInt = 2000;

    //System.out.println("静态代码块执行了");

  }




  /*
    局部代码块
 */
  public void testLocalBlock() {
    //int i;

    //这就是一个典型的局部代码块
    {
      int i = 0;
      System.out.println(i);
    }

    //System.out.println(i);
  }
}

 

3. package关键字

package com.cskaoyan.syntax.keypackage;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 * 在Java 源程序文件的第一行使用package 声明可以使文件中定义的类成为指定包的成员
 *
 *  package声明的语法如下：
    　　　package 包名;

　　　 包名通常由多个名字字符串构成，中间用句点“.”分隔，每个名字表示的包称为其前面的名字表示的包的子包。

　　　 通常以组织机构的域名反转形式作为其所有包的通用前缀，比如：com.somecompany.apps

    注意：Java中定义的任何一个类，都是一定是在某一个包下的
         即使，我们的代码没有用package关键字声明，类所属的包，此时这样类其实仍然，在java中的一个默认包中
 */
public class Demo1 {

}

class TestPackage {

}

 

4. import关键字

 

package com.cskaoyan.syntax.keyimport.onepackate;


//import com.cskaoyan.object01.syntax.keyimport.otherpackage.*;


import com.cskaoyan.syntax.keyimport.otherpackage.B;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 * import关键字：
 * 1. 预备知识，全限定类名，全类名
 *    在类名前面加上类所属的包名，中间用句点“.”分隔，
 *    称为类的完全限定名(Full Qualified Name)，简称类的全限定名
 *
 *    比如说：这里的Demo1这个类，其全类名 包名+类名: com.cskaoyan.object01.syntax.keyimport.onepackate.Demo1
 *    java语言中，我们是根据类的全限定名，唯一确定一个类
 *
 *
 *    当在类体中使用了与当前类不同包的类名时，编译器编译时因为无法找到该类的定义而报错
 *    1. 使用类的全限定名
 *    2. 使用import关键字，在当前Java文件中，导入其他包下的类，信息
 *
 *    import注意事项
            1. import声明一般紧跟在package声明之后，必须在类声明之前，其基本语法如下:
                  import 类的完全限定名;
            2. Java语言核心包java.lang包中的类 将被隐式导入，可以直接使用其中的类
            3. import声明提供了一种包的智能导入方式：
               import <包名>.*；
              包中的类将 根据需 要导入，避免使用多条import声明
              注意事项：
              a. 智能导包，不会递归导入子包中的类
              b. 导入方式，按需导入

 *
 */
public class Demo1 {

  public static void main(String[] args) {
    // 当使用其他包中的类(public)，可以用全限定名，告诉编译器我们要使用的究竟是哪个类
    // com.cskaoyan.object01.syntax.keyimport.otherpackage.A a = new com.cskaoyan.object01.syntax.keyimport.otherpackage.A();
    //第二种解决方案，利用import关键字，导入其他包中的类
    A a = new A();

    //String s = "hello world";


    //当我们需要使用其他包中的，多个类的使用，可以使用，imort的智能导包方式，来一次导入多各类
    B b = new B();

    // 智能导包方式，不会递归导入，某个包中，子包定义的类
    //D d = new D();


  }

}

 

面向对象思想oopthinking

package com.cskaoyan.oopthinking;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 * 面向过程思想：
    所谓面向过程的编程思想，简单理解，程序是“动词”的集合，
    即程序功能是由一系列有序的动作来完成。

   面向对象的思想：
    所谓面向对象的编程思想，简单理解，程序是由一系列的 对象(消息)+消息 组成，
    即程序是由一系列的对象和对象间的消息组成。

    举一个例子，用代码来模拟：完成，将大象装进把冰箱
 */
public class Demo1 {

  /*
      用面向过程的思想，写代码模拟：将大象装进把冰箱
      得把这个问题，转化成一些列动作集合：
      1. 打开冰箱
      2. 将大象塞进冰箱
      3. 关上冰箱
   */
  public void prodcedure() {
    //1. 打开冰箱
    //2. 将大象塞进冰箱
    //3. 关上冰箱
  }

  /*
      用面向过对象的思想，写代码模拟：将大象装进把冰箱
      所谓向一个对象发送消息：就是指在这个对象上，调用其成员方法
   */
  public void oop() {
    // 冰箱对象.in(大象对象)
  }


}

 

 

 

面向对象和面向过程的比较：

1.结构化程序设计(面向过程程序设计)

• 对应的典型的计算机语言, 例如: C
• 面向操作的
• 函数(方法)是程序的基本单位

 

2.面向对象程序设计

• 对应的典型的计算机语言, 例如: Java, C++, C#
• 面向对象(object)的
• 类(class)是程序的基本单位

Java面向对象——Javaobject02

1.访问权限修饰符

　　在Java语言中，一切事物（类所有成员）都具有(或显示定义或隐式定义的)访问权限，而这种语言层面的访问权限控制，是由访问权限修饰符实现。

访问权限修饰符的访问控制，分为2个层面：

• 修饰类中成员(field & method)

　　   控制类中的成员，对其他类可见性(其他类是否可以直接使 用到)

• 修饰类

　　   通常用来限定，类库中的类(自定义数据类型)，对于外部使用者的可见性(是否能使用该类型)。

 

 

1.对类中成员的访问控制

对于类中成员的访问，可以使用的访问权限修饰符有4种：

• • public： 任意类均访问，实际就是没有限制访问权限
  • protected 同包中的其他类，和不同包的(可见)子类均可见
  • default(默认权限，隐式定义) 同包中的其他类可见
  • private 仅对同类中的其他成员可见

 

 

                                图：各权限修饰符对成员的可见性的影响

package com.cskaoyan.object02.access.onepackage.member;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 * 对类中成员的访问控制

对于类中成员的访问，可以使用的访问权限修饰符有4种：

        public：
         任意类均访问，实际就是没有限制访问权限
        a. 类体中，可以直接访问
        b. 同包的其他类中，也可以访问
        c. 不同包的的类中，也可以访问

        protected
        同包中的其他类，和不同包的(可见)子类均可见
        a. 类体中，可以直接访问
        b. 同包其他类中，可以访问
        c. 在非同包的一部分类中，访问不到，????????还有一部分(子类中可以访问到，父类中被protected)

        default(默认权限，隐式定义)
        a. 类体中，可以直接访问
        b. 同包其他类中，可以访问
        c. 不同包的类中，访问不了

        private
        仅对同类中的其他成员可见
        a. 类体中，可以访问
        b. 同包其他类中，无法访问
        c. 非同包中，无法访问

 *
 *
 *
 */
public class MemberAccess {

  // 具有public访问权限的成员变量
  public double publicValue;

  // 具有受保护的访问权限的成员变量
  protected boolean protectedValue;

  // 具有默认访问权限的成员变量
  int defaultValue;

  // 具有私有访问权限的成员变量
  private byte privateValue;


  /*
        在定义成员的类体中，不同访问权限的陈成员，能否被访问到
   */
  public void testAccess() {
    // 测试

    //public
    System.out.println(this.publicValue);

    //protected
    System.out.println(this.protectedValue);

    //默认访问权限
    System.out.println(this.defaultValue);

    //private访问权限
    System.out.println(this.privateValue);

    MemberAccess memberAccess = new MemberAccess();
    System.out.println(memberAccess.publicValue);
    System.out.println(memberAccess.protectedValue);
    System.out.println(memberAccess.defaultValue);
    // 私有成员变量
    System.out.println(memberAccess.privateValue);

  }

  // protected
  protected void protectedMethod() {}

  // 默认访问权限
  void defaultMethod() {}

  // 私有访问权限
  private void privateMethod() {}


}

 

package com.cskaoyan.object02.access.onepackage.member;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 */
public class TestMemberAccess {

  public static void main(String[] args) {

    // 在同包中的其他类中，访问其他类中定义的不同访问权限的成员
    MemberAccess memberAccess = new MemberAccess();

    //public  可以访问
    System.out.println(memberAccess.publicValue);

    //protected 可以访问
    System.out.println(memberAccess.protectedValue);

    //默认访问权限 可以访问
    System.out.println(memberAccess.defaultValue);

    //private 私有访问权限  访问不到
    //System.out.println(memberAccess.privateValue);

  }

}

 

2. 对类的访问控制

能够修饰类的访问权限修饰符只有2种：

• public 对其他任意类可见
• default：对同包中的其他类可见

package com.cskaoyan.object02.access.onepackage.classes;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 *  类的访问权限：
 *    1. 只有两种，public 和 默认访问权限
 *
 *  具有public权限的类所具有的访问特征：
 *     在任何其他地方都可以访问到这个类(同一个module下)，比如：同包中的其他类，以及非同包的其他类
 *
 *  具有默认访问权限的类所具有的访问特征：
 *    同包中的其他类，可以访问，非同包的类访问不了
 *
 */
public class Demo1 {

  public static void main(String[] args) {

    //当我们创建对象的时候，就会需要使用类定义信息来创建对象，此时会访问类
    //DefaultClass defaultClass = new DefaultClass();

  }

}

// protected 不能用来修饰类
//protected class protectedClass{}

// 具有默认访问权限的类
class DefaultClass {}

//private  不能用来修饰类
//private class PrivateClass {}

 

package com.cskaoyan.object02.access.onepackage.classes;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 */
public class TestClassAccess {

  public static void main(String[] args) {

    // public修饰的类
    Demo1 demo1 = new Demo1();


    //访问默认访问权限的类
    DefaultClass defaultClass = new DefaultClass();
  }

}

 

package com.cskaoyan.object02.access.otherpackage;

import com.cskaoyan.object02.access.onepackage.classes.Demo1;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 */
public class TestClassAccess {

  public static void main(String[] args) {
    // 访问public修饰的的类
    Demo1 demo1 = new Demo1();

    // 访问默认访问权限的类, 其他包中访问不到
    // DefaultClass defaultClass = new DefaultClass();
  }

}

 

package com.cskaoyan.object02.access.otherpackage;

import com.cskaoyan.object02.access.onepackage.member.MemberAccess;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 */
public class TestMemberAccess {

  public static void main(String[] args) {
    // 在同包中的其他类中，访问其他类中定义的不同访问权限的成员
    MemberAccess memberAccess = new MemberAccess();

    //public  可以访问
    System.out.println(memberAccess.publicValue);

    //protected
    //System.out.println(memberAccess.protectedValue);

    //默认访问权限 不可以访问
    //System.out.println(memberAccess.defaultValue);

    //private 私有访问权限  访问不到
    //System.out.println(memberAccess.privateValue);
  }

}

 

为什么要使用访问控制修饰符？

• 使用户不要触碰他们“不该”触碰的代码（private）
• 类库设计者可以安全的修改实现细节

2.面向对象3大特征之封装（encapsulate）

封装是一种信息隐藏技术。

• 是指将数据和基于数据的操作封装在一起
• 数据被保护在内部
• 系统的其他部分只有通过在数据外面的被授权的操作才能够进行交互
• 目的在于将类使用者class user和类设计者class creator分开。

在面向对象的编程中，用类来封装相关的数据和方法，保证了数据的安全和系统的严密性。

 

package com.cskaoyan.object02.encapsulate;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 *
 * 针对private成员变量，专门定义public的方法，让外部能够访问私有成员变量的值
 *  get：让外部读取到私有成员变量值
 *  set：让外部通过该方法，修改私有成员变量的值
 *
 *  同时，为了清楚的表名get和set分别获取和改变的 是 哪个成员变量的值
 *  常规命名规则：
 *  xxx
 *  getXxx()
 *  setXxx(修改目标值参数)
 *
 *  注意：
 *    提供get，set方法的好处：
 *    1. 可以满足，某些场景下，需要访问私有成员变量值的需求
 *    2. 通过定义get和set方法，来实现了对私有成员变量的读写分离
 *    3. 因为，一旦一个成员变量，一旦被private修饰，别人就无法直接 对象名.访问
 *       只能通过，set()，此时我们在set方法中，就可以自己通过代码控制，别人的修改
 *
 *
 *   类
      成员变量(一定要考虑访问权限)
      构造方法
        无参构造方法
        带参构造方法
      成员方法
        getXxx()
        setXxx()

    给成员变量赋值的方式
          1.无参构造方法 + setXxx()
          2. 带参构造方法


 *
 *
 */
public class Demo1 {

  public static void main(String[] args) {
    Student student = new Student("张三", 18, false, 1);

    // 一旦类中成员，被private，该成员变量的值，就不能被别人轻易的访问到了
    //System.out.println(student.name);

    // 比如说，教务处的老师，这类特殊的存在，应该有权限能访问到学生的私有信息
    student.setName("");
    System.out.println(student.getName());

  }

}


class Student {

  private String name;

  private int age;

  private boolean isMale;

  private int sno;

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

  /*
        专门用来给外部，返回私有成员变量name的值
     */
  public String getName() {
    return this.name;
  }

  /*
      专门用让外部，可以修改私有成员变量name的值
   */
  public void setName(String name) {
    // 自己可以根据需要做一些检查
    if (name == null || name.equals("")) {
      return;
    }

    this.name = name;
  }

  public int getAge() {
    return age;
  }

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

  public boolean isMale() {
    return isMale;
  }

  public void setMale(boolean male) {
    isMale = male;
  }

  public int getSno() {
    return sno;
  }

  public void setSno(int sno) {
    this.sno = sno;
  }
}

 

 

3.面向对象3大特征之继承（extend）

引例

根据我们刚刚学过的知识，完成如下练习:

• 分别定义一个表示人和学生的类
• 表示人的类有姓名属性，以及吃饭，睡觉的行为
• 表示学生的类有姓名，学号两个属性，同时有吃饭，睡觉，学习3种行为

版本1，直接写：

package com.cskaoyan.object02.extend.introduction.edition1;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 * 根据我们刚刚学过的知识，完成如下练习:
    分别定义一个表示人和学生的类
    表示人的类有姓名属性，以及吃饭，睡觉的行为
    表示学生的类有姓名，学号两个属性，同时有吃饭，睡觉，学习3种行为

 */
public class Demo {

}

class Person {

  String name;

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

  public void sleep() {
    System.out.println(name + "sleeping");
  }
}

class Student {

  String name;

  //学号
  int sno;

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

  public void sleep() {
    System.out.println(name + "sleeping");
  }

  public void study() {
    System.out.println(name + "studying");
  }
}

class Teacher {


}

版本2，用继承：

package com.cskaoyan.object02.extend.introduction.edition2;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 * 根据我们刚刚学过的知识，完成如下练习:
      分别定义一个表示人和学生的类
      表示人的类有姓名属性，以及吃饭，睡觉的行为
      表示学生的类有姓名，学号两个属性，同时有吃饭，睡觉，学习3种行为
 */
public class Demo1 {

  public static void main(String[] args) {
    Student student = new Student();
    System.out.println(student.name);
    student.eat();
    student.sleep();
  }

}

class Person {

  String name;

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

  public void sleep() {
    System.out.println(name + "sleeping");
  }
}

//我们使用继承的方式，复用已有的类定义代码，即继承Person类中定义的成员
class Student extends Person {

  //学号
  int sno;

  public void study() {
    System.out.println(name + "studying");
  }
}

继承概述

package com.cskaoyan.object02.extend.basic;

/**
 * @author zhangshuai@Cskaoyan.onaliyun.com on 2020/4/16.
 * @version 1.0
 *
 * 继承概述
        Java中的继承 和 我们现实生活中的“继承”的含义基本类似，但是含义更广。
        1. 简单来说都可以表示“不劳而获”（类似于现实世界中继承的含义）
        2. 类型之间 “ is a” 的关系    一种类型(类) 继承 另外一种类型(类)

        被继承的类称之为父类(基类或超类)，继承其他类的类称之为子类(派生类，导出类)
        子类可以通过继承机制，不写任何额外代码就可以拥有父类的“所有”成员。
 */
public class Demo1 {

}

// 父类(基类，超类)
class Father {}
// 继承其他类的类称之为子类(派生类，导出类)
class Son extends Father{}

 

4.面向对象3大特征之多态