权限修饰符

import 关键字：当在类体中使用了与当前类不同包的类名的时候，编译器编译时会因为无法找到该类的定义而失败。
解决办法：1、使用不同包类的完全限定名

完全限定名：包名+类名----在类名前面加上类所属的包名，中间用 “ . ”分隔

2、使用import声明，为编译器提供该类的定义信息。一般只会在同包下去寻找这个类，但只要使用了import关键字，编译器会优先采纳import中声明的信息。

import 注意事项：
1、import 声明一般紧跟在package 声明之后，必须在类声明之前，其基本语法： import 类的完全限定名 ；

2、Java 语言核心包 java . lang 包中的类将被隐式导入，可以直接使用其中的类

3、import 声明提供了一种智能导入方式： import 包名 . * ; 但这种导包方式只能导入在这个包中定义的类，不会自动导入这个包的子包中的类。

访问权限修饰符：1、修饰类中成员，控制类中的成员，对其他类可见性<其他类是否可以直接使用到>

2、修饰类，通常用来限定类库中的类，对于外部使用者的可见性<能否直接使用该类型>

		package com.cskaoyan.access.onpackage;  
	    public class Demo1MemberAccess {
	      //public 修饰的成员变量
	      public int publicValue = 1000;
  	
	      //protected
	      protected double protectedValue = 1.5;
	
	      //默认权限
	      String defaultValue;
	
	      //private权限
	      private char privateValue;
	
	      //public成员方法
	      public void publicMethod() {
	        System.out.println("publicMethod");
	      }
	
	      //protected
	      protected void protectedMethod() {
	        System.out.println("protectedMethod");
	      }
	
	      //默认权限的方法
	      void defaultMethod() {
	        System.out.println("defaultMethod");
	      }	

          //private 方法
          private void privateMethod() {
            System.out.println("privateMethod");
          }

          public void testAccessInMethod() {

            //测试public
            System.out.println(publicValue);
            publicMethod();

            Demo1MemberAccess pubicTest = new Demo1MemberAccess();
            System.out.println(pubicTest.publicValue);
            pubicTest.publicMethod();

            //测试protected
            System.out.println(protectedValue);
            protectedMethod();

            //测试默认访问权限
            System.out.println(defaultValue);
            defaultMethod();

            //测试private
            System.out.println(privateValue);
            protectedMethod();

            //可以 在类体中创建对象访问
            Demo1MemberAccess privateTest = new Demo1MemberAccess();
            System.out.println(privateTest.privateValue);
            privateTest.privateMethod();

          }

        }

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

1、public 任意类均可访问，实际就是没有限制访问权限；类体中，可以直接访问；同包的其他类中，也可以访问；不同包的类中，也可以访问。

2、prtected 同包中的其他类和不同包的子类可见； 类体中，可以直接访问；同包其他类中，可以访问；在不同包的一部分类中，访问不到，但还有一部份类访问得到<得是这个子类对象，才能访问到父类中protect 成员>。

    package com.cskaoyan.access.otherpackage;

    import com.cskaoyan.access.onpackage.Demo1MemberAccess;

    public class TestProtected  extends Demo1MemberAccess{

      public static void main(String[] args) {
        // 静态上下文不能访问非静态的成员
        // System.out.println(protectedValue);
      }

      public void testAccess() {
        // 能否在类体中直接访问
        System.out.println(protectedValue);

        //创建对象访问

        // 在子类类体中，无法通过创建父类对象，访问父类的preotected成员
        //Demo1MemberAccess access = new Demo1MemberAccess();
        //System.out.println(access.protectedValue);

        // 得是 这个子类对象，才能访问到父类中protected成员
        TestProtected testProtected = new TestProtected();
        System.out.println(testProtected.protectedValue);
      }
    }

3、default 默认权限，隐式定义；类体中，可以直接访问；同包其他类中，可以访问；不同包的类中访问不到。
4、prviate 仅对同类中的其他成员可见；类体中，可以直接访问；同包的其他类中，访问不了；不同包的类中，访问不了。

    	package com.cskaoyan.access.onpackage;
    	
    	    public class TestMemberAccess {
    	
    	      public static void main(String[] args) {
    	        Demo1MemberAccess access = new Demo1MemberAccess();
    	
    	        //public
    	        System.out.println(access.publicValue);
    	        access.publicMethod();
    	
    	        //protected访问权限
    	        System.out.println(access.protectedValue);
    	        access.protectedMethod();
    	
    	        //默认访问权限
    	        System.out.println(access.defaultValue);
    	        access.defaultMethod();
    	
    	        //private 访问不到
    	        //System.out.println(access.privateValue);
    	        //access.privateMethod();
    	      }
    	    }
    	     输出结果：	 1000
    	                publicMethod
    	                1.5
    	                protectedMethod
    	                null
    	                defaultMethod

对类的访问权限控制：能够修饰类的权限访问修饰符只有两种：

1、 public ：对其他任意类可见

2、 default ： 对同包中的其他类可见

      package com.cskaoyan.access.onpackage;   
        //public访问权限
        public class Demo2ClassAccess {

        }

        // protected 无法修饰类
        //protected class ProtectedClass {}

        //默认访问权限
        class DefaultClass {}

        //private 无法修饰类
        // private class PrivateClass {}

        public class TestClassAccess {

          public static void main(String[] args) {

            //创建对象的时候，会访问对象所属的类 可以访问
            DefaultClass defaultClass = new DefaultClass();
          }

        }

面向对象三大特征之封装：是一种信息隐藏技术，是指将数据和基于数据的操作封装在一起。数据被保护在内部（通过访问权限），系统的其他部分只有通过数据外面的被授权的操作才能够进行交互（访问）。目的在于将类使用者和类设计者分开，避免被人误修改。

/*
 类:

成员变量
     (一定要考虑访问权限)在开发中，通常我只给最小权限private

构造方法
    无参构造方法
    带参构造方法

成员方法
    public   getXxx() 获取 Xxx 成员变量的的值
    public   setXxx() 修改 Xxx 成员变量的值

    1. 可以在方法中，作一些控制
    2. get，set方法，对成员变量的访问，做了读和写分离

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

 */
    public class Demo1 {
      public static void main(String[] args) {

        //带参构造方法
        Student zhangsan = new Student("张三", 18, true, 1);

        //假设教务处的老师，修改学生的相关信息
        //zhangsan.name = "张四";
        //System.out.println(zhangsan.getName());
        //zhangsan.setName("张四五六");
        //System.out.println(zhangsan.getName());

        //1.无参构造方法 + setXxx()
        //2. 带参构造方法

        Student student = new Student();
        student.setName("zhangsan");
        student.setAge(18);
        student.setIsMale(true);
        student.setSno(1);
        System.out.println(student.getName() + "--" + student.getAge()
            + "--" + student.getIsMale() + "--" + student.getSno());

        //带参构造方法
        Student lisi = new Student("lisi", 18);
        lisi.setIsMale(false);
        lisi.setSno(2);

      }

    }

    class Student {

      private String name;

      private int age;

      private boolean isMale;

      private int sno;

      public Student() {
      }

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

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

      // 我定义两个方法，分别，可以让其他类，获取或者改变私有成员变量的值

      //定义get方法让外界获取name成员变量的值
      public String getName() {
        return name;
      }

      //定义set方法让外界修改name成员变量的值
      public void setName(String name) {

        //我就可以来做一些控制了，控制符合条件的值可以设置，不符合条件的值，不让你修改
        //if (name.length() > 3) {
        //  return;
        //}
        this.name = name;
      }

      public int getAge() {
        return age;
      }

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

      public boolean getIsMale() {
        return isMale;
      }

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

      public int getSno() {
        return sno;
      }

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