包与访问权限

1.包

​
每一个类都有对应的路径，在哪？
  
1) 包声明
    package 包名;      package com;
    package 包名1.包名2.包名3;   package com.uplooking.test;
2) 导入其他类    声明 当前这个类中使用的 类所在的路径在哪里。
    import 包名.类名;    import  com.Test;
    import 包名.*;  将对应的包下面所有类都导入过来。  import  com.*;
3)  同一个源文件中的类，都是在同一个包下，相互引用时，可以不用导包。
4)  aaa.bbb.ccc  和   aaa.bbb 之间，我们可以认为这是连个完全不同的包。没有任何关系，只是体现在体统磁盘上面是父子文件夹。
 
5)   如果编译的时候，想生成对应文件夹层次。
    javac -d . Test.java
  
6)   java.lang 包下的类使用时不用导包
    String  Integer   。。。  Object 

2.访问权限

 x public   被它修饰的类、属性、方法 ，不仅可以跨类访问，也可以跨包访问。protected  可以修饰成员、构造函数、方法  但是不能修饰类。被它修饰的只能在本类、同包 、子类跨包private  修饰 成员、构造函数 、方法  但是不能修饰类。被它修饰的只能在本类中使用什么都不写（default）：只允许在同一个包下面访问。  private < default < protected< public        
   例子一：  同一个包下面的类
   
   
例子二： 不是同一个包下面的。（private   public）  
  package com.bean;
  public class User {
​
      private String a ;
      private int b ;
​
      public String getA() {
          return a;
      }
      public void setA(String a) {
          this.a = a;
      }
      public int getB() {
          return b;
      }
      public void setB(int b) {
          this.b = b;
      }
  }
                                                     
package com;
​
import com.bean.User;
​
public class Test {
    public static void main(String[] args) {
        
        User u = new User();
        
        u.setA("uplooking");
        u.setB(11);
        
        String a = u.getA();
        int b = u.getB();
        
        System.out.println(a+b);
        
    }
}
​
​
  例子3：
    package cn.dao;
​
public class Cat {
​
    protected void shut(){
        System.out.println("miao....");
    }
}
​
​
package cn.util;
​
import cn.dao.Cat;
​
public class NiceCat extends Cat{
​
    
    void  test(){
        super.shut();//  protected 可以访问到
        Cat c = new Cat();
        c.shut();//出错，无法访问到。
    }
}
​
 以  User    Customer  在不同包下面定义 为例子。  演示： public  protected   private   default

3.jar包

​
java中的jar文件 ,装的是 .class 文件
        就是一种压缩,和zip兼容
        称为jar包
        
        很多类,把这些类和他们的目录一起压缩到一个文件中给别人,显得专业不零散了
        别人拿到这个jar包之后,只要让他的classpath 的设置中包含 这个jar文件,java虚拟机,在装载类的时候,就会自动解压这个jar文件,
        将其当成目录,然后在目录中查找我们所要的类及类的包名和所对应的目录的结构
        jdk提供的许多类,也是以jar的形式提供的
  
  操作： 看视频。
  
  

4.finalize方法（objcet中的方法）

​
public class Dog {
    public static void main(String[] args) {
        
        new Dog().test();
        // 没有使用到Cat c 这个对象。
        // 应该回收内存。
        // java中没有手工回收内存的函数。
        // 通过垃圾回收机制  回收内存。
    }
    void test(){
        Cat c = new Cat();
        c.age = 7 ; 
        c.name = "tom";
        System.out.println(c.age);
    }
}
// 在回收内存的时候会调用 finalize方法。
​
package com.uplooking;
public class Cat {
    String name;
    int age;
    
     @Override
     protected void finalize() throws Throwable { 
         
         System.out.println("啊 。。。我死掉了。");
     }
}
​
public static void main(String[] args) {
        Cat a  =new Dog().test();
        a = null;
        System.gc();// 唤起垃圾回收器工作，回收内存  不推荐调用gc(); jvm 有一个算法 ，。
    }

5.lambda表达式

 lambda表达式 就是对匿名内部类的一种简化写法
public class Test2 {
​
    public  int a ;
    
    public static void main(String[] args) {
        
        /*Animal  a = new Animal(){
            @Override
            public void eat() {
                System.out.println("这是一头牛");
            }
        };
        a.eat();*/
        
        // lambda表达式   java8 的新特性
        Animal a  = ()->{System.out.println("这是一头牛");};
        a.eat();
        
    }
}
​
lambda 表达式特点：
            1)  必须是函数式接口 ？
                    函数式接口：接口中有且只有一个抽象方法。
                        @FunctionalInterface
                        public interface Animal {
                            public abstract void eat();
                            //void sleep(int  i);
                        }
            2) 参数类型可以省略 @FunctionalInterface 可以校验函数式接口。
              
              @FunctionalInterface
              public interface Animal {
                  public abstract String eat(int a ,String b);
              }
             Animal a = (int c ,String b)->{return null;};
            
            例子： 在方法体使用对应的参数
              Animal a = ( c , b)->{
                  b ="一头牛";
                  System.out.println(b+"吃了"+ c+"斤");    
                  return null;
              };
              a.eat(100, "黄牛");
​
            3)函数体重如果只有一句，函数体的大括号可以省略，如果有返回值，return也要省略 
              Animal a = ( c , b)->  b;
            
            4) 抽象类不能使用lambda 表达式
              @FunctionalInterface
                public abstract class Person {
​
                    abstract void test();
                }
​
​
练习： 
        interface  Math{
            int  add(int a ,int b );
        }
​
        使用lambda表达式  实现上面的类。
          
          
      
​

6内部类

  内部类： 可以放在函数中，也可以放在类中。 
          放在类中就是类的成员。  同样可以访问 类中其他成员
          类中也可以存在接口和抽象类。 内部接口。
    
    package com.uplooking;
​
    public class Cat {
​
        String name;
        int age;
​
        class LittleCat{
            void test(){
                System.out.println(name+age);
            }
        }
    }
会发现生成了两个class文件：Cat$LittleCat.class    Cat.class
  
  
  
  例子：
            public static void main(String[] args) {
              Cat c = new Cat();
              c.age = 7 ; 
              c.name = "tom";
​
              LittleCat c2 =c.new LittleCat();
​
              c2.test();
​
          }
​
          public class Cat {
​
              String name;
              int age;
​
              static String color;
​
              static class LittleCat{
                  void test(){
                      System.out.println(color);
                  }
              }
          }
​
            静态内部类：
                创建对象方式。
                Cat.color = "小老虎";
                Cat.LittleCat  l = new Cat.LittleCat();
                l.test();
​
        
    例子:  当内部类与主类中的属性冲突时；
      
        public class Cat {
​
            String name;
            int age;
​
            static String color;
​
             class LittleCat{
                String name;        
                void test(){
                    System.out.println( Cat.this.name); // 调用的是 全局的name
                }
            }
        }
​
    
    例子： 内部类 放在方法里面
            package com.uplooking;
​
            public class Cat {
                String name;
                int age;
                static String color;
                void test(){
                    class LittleCat{
                        String name;        
                        void test(){
                            System.out.println(name);
                        }
                    }
                    LittleCat cat = new LittleCat();
                    cat.name = "aaa";
                    cat.test();
                }
            }
​