java 的面向对象

Java基础系列

1. 面向对象简介：

OOP:
  Oriented object  program:面向对象编程
OOA:
  Oriented object analyze:面向对象分析
OOD:
  Oriented object design:面向对象设计
 Java 讲 一切面向对象

1.1 理解面向对象

1. 面向对象是相对面向过程而言
2. 面向对象和面向过程都是一种思想
3. 面向过程
    3.1 强调的是功能与行为
4. 面向对象
   将功能封装进行对象，强调具备了功能的对象
5. 面向对象是基于面向过程的。

1.2 面向对象的特点：

1. 是一种符号人民思考习惯的思想
2. 可以将复杂的事情简单化
3. 将程序员从执行者转换为指挥者
4. 完成需求时：
   4.1 先要去找具体所需的功能的对象来用。
   4.2 如果该对象不存在，那么创建一个具有所需功能的对象
   4.3 这样简化开发并提高复用

1.3 面向对象开发，设计，特征

1. 开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
2. 设计的过程： 其实就是在管理和维护对象之间的关系。
3. 面向对象的特征：
    3.1 封装（encapsulation）
    3.2 继承（inheritance）
    3.3 多态（polymorphism）
    对象就是切实存在的个体
4. 类的概念：
    物以类聚，人以群分
    对现实事物的软件抽象

1.4 类与对象的关系

1. 使用计算机语言就是不断的在描述现实生活中的事物
2.Java中描述事物通过类的形式体现。
类似具体事物的抽象，概念上的定义
3.对象就是该类事物实实在在存在的个体

1.5 类的定义：

1. 生活中描述事物无非就是描述事物的属性和行为：
   如：人有身高，体重等属性，有说话，打球等行为
2. Java 中类class 来描述事物也是如此
    属性：对应类中的成员变量
    行为：对应类中的成员函数
3. 定义类其实在定义类中的成员（成员变量和成员函数）
类的成员：
  1. 成员变量
         属性
   数值类型的基本数据类型，默认值是0
  2. 成员函数
         方法
  3. 定义方式
       class   // 类名
      // 首字母大写。$_开头
堆：数组和对象在堆中
栈： 方法在栈中

1.6 成员变量与局部变量的区别

成员变量：
    1. 成员变量定义在类中，在整个类中都可以访问
    2. 成员变量随着对象的建立而建立，存在于对象所在的堆内存当中。
    3. 成员变量有默认初始化值。
局部变量：
  1. 局部变量只定义在局部范围内，如：函数内，语句内等
  2. 局部变量存在于栈内存中
  3. 作用的范围结束，变量空间会自动释放
  4. 局部变量没有初始化值

package com.learnjava.day04;
public class ClassDemo01 {
    public static void main(String[] args) {
        //创建对象
        //局部变量
        Persion p = new Persion();
        p.age = 14;
        p.hight = 165;
        p.weight = 160;
        System.out.println(p.age);
        p.run();
    }
}
class Persion {
    //成员变量
    int hight;
    int weight;
    int age;
    //成员方法
    public void run() {
        System.out.println("run.........");
    }
}

1.7 Java 的堆栈

栈是存放方法的，先进后出
所有方法的都在栈中

1.8 java 堆栈的的溢出问题

• 1.8.1 Java的 栈溢出

package com.learnjava.day04;
public class StackHeapDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        byte [] arr = new byte[4 * 1024 * 1024 * 1024];
        System.out.println("ok");
    }
}

package com.learnjava.day04;
public class StackHeapDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //输出负数了，二进制的最高位移位。
        byte [] arr = new byte[78 * 1024 * 1024 * 1024];
        System.out.println("ok");
    }
}

package com.learnjava.day04;
public class StackHeapDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
         // 堆溢出
        byte [] arr = new byte[Integer.MAX_VALUE];
        System.out.println("ok");
    }
}

Java VM 调整堆大小
java -X ： 查看Java 费标准输出帮助
    -- java -xmx 80M StackHeapDemo
    -- Java -Xms100M // 设置jvm 的堆空间的初始大小
    -- Java - Xmx100 // 设置对空间的最大值
    java 默认的堆大小是物理内存的1/4
    一般会设置两个一样大，这样就避免以后再分配内存

• 1.8.2 Java的栈溢出

package com.learnjava.day04;
public class StackHeapDemo01 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        while(true) {
            out();
        }
    }
     public static void  out() {
         System.out.println("kkkkk");
     }
}

package com.learnjava.day04;
public class StackHeapDemo01 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i = 0;
        while(true) {
            out(i++);
        }
    }
     public static void  out(int i) {
         System.out.println(i);
     }
}

package com.learnjava.day04;
public class StackHeapDemo01 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
//      int i = 0;
//      while(true) {
//          out(i++);
//      }
        out(1);
    }
     public static void  out(int i) {
         System.out.println(i);
         out(i+1);
     }
}

要想栈溢出必须只压栈，不弹栈，方法的死循环，不停的迭代。
Java的栈的设置：  
      java -Xss 10M stackHeapDemo01 

一般情况下，调的是堆的大小。栈不调解，栈默认是1M 

1.9 对象的内存结构

1.10 jvm 堆栈初探

一： 查看运行的Java 进程
     jps [v] //显示可提取PID
二：查看指定Java进程的对空间
    jmap -heap pid // jmap 也是jdk 自带工具
              // linux 下切换到root。
三： Java中对象和数组位于堆内存当中，局部变量。函数参数等位于栈内存当中。
四：默认jvm 分配的栈空间大小是1M
五： 默认jvm分配的堆空间是最大值是1/4 物理内存。

1.11 匿名对象

1. 匿名对象是对象的简化形式
2. 匿名对象两种使用情况
    1. 当对对象方法仅进行一次调用的时。
    2. 匿名对象可以昨晚实际参数进行传递。

package com.learnjava.day04;
public class ClassDemo01 {
    public static void main(String[] args) {
        //创建对象
        //局部变量
        Persion p = new Persion();
        Persion p1 = new Persion();
        p.age = 14;
        p.hight = 165;
        p.weight = 160;
    //  Persion p1 = p;
        // 匿名对象。 只访问一次。
        new Persion();
        new Persion().age = 18 ;
        // 做为参数进行传参
        run0(new Persion());
//      System.out.println(p.age);
//      p.run();
//      p.seep();
//      System.out.println(p1.weight);
    }
       public static void run0(Persion p) {
           p.run();
       }
}
class Persion {
    //成员变量
    int hight;
    int weight;
    int age;
    //成员方法
    public void run() {
        System.out.println("run.........");
    }
    public void seep() {
        System.out.println("zzzzz~~~~~~");
    }
}

1.12 面向对象封装：

1. 封装（encapsulation）
   封装:是指隐藏对象的属性和实现细节，仅提供访问方式。
2. 好处： 
   2.1 将变化隔离
   2.2 便于使用
   2.3 提高重用性
   2.4 提高安全性
   ---
3. 封装的原则：
   3.1 将不需要对外提供的内容都隐藏起来
   3.2 把属性都隐藏，提供公共方法对其访问。
4. private (私有)关键字
    1. 是一个权限修饰符
    2. 用于修饰成员（成员变量和成员函数）
    3. 被私有化的成员只在本类中有效。
    常用之一：
    将成员变量私有化，对外提供对应的set ,get 方法对其进行的访问
    提高对数据访问的安全性

package com.learnjava.day04;
public class ClassDemo03 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        RichMan wsc = new RichMan();
        wsc.setMoney(10000000);
        System.out.println(wsc.getMoney());
    }
}
class RichMan {
   private  int money ;
public int getMoney() {
    return money;
}
public void setMoney(int money) {
    this.money = money;
}
}

1.13 构造函数：

1. 函数名和类型相同
2. 没有返回值
      -- 2.1 创建之后肯定返回的该对象。
3. 如果类没有定义构造函数,jvm分配一个空构造
   如果类定义了构造函数，没有空构造
 4. 构造函数也可以重载
特点： 
1. 函数名与类名相同
2. 不用定义返回值类型
3. 没有具体的返回值。
作用：
 给对象进行初始化
注意：
 1. 默认构造函数的特点
 2. 多个构造函数式是以重载的形式存在的。

1.14 构造代码块

1.代码块：
  代码中使用单独的{} 围起来的内容
2. 构造代码块
   2.1 类的成员之一
   2.2 使用{} 起来的一段代码
   2.3 创建对象时，先于构造函数调用
3. 局部代码块
  方法内定义的代码块。
----
对象创建过程：
  1. 构造代码块
      从上到下按顺执行。
  2. 构造函数
  3. 成员变量
      a.color = null;
      b.color = "black";
      c.构造代码块
      d.构造函数
  4.Javabean 
     pojo : plain old java object ;
   class Dog {
      private String color ;
      public String getColor(){
        return color;
      }
   }     
类的成员：
    成员变量
    成员函数
    构造函数
    构造代码块
    静态代码块： 类加载之前进行，而且只执行一次
静态成员之间可以相互访问，按序执行
静态成员不可以访问非静态成员。
非静态成员可以访问静态成员。
静态成员通过类访问（和对象无关 person.boold）
    使用static 修饰的代码构造块，在类的加载时调用一次，以后不在调用，通常放置对静态成员变量的初始化过程。

package com.learnjava.day05;
public class DemoPerson {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        {
            System.out.println("3. 构造代码块");
        }
        Person p = new Person();
        p.setName("小明");
        System.out.println(p.getName());
        p.setAge(18);
        System.out.println(p.getAge());
        System.out.println(Person.blood);
    }
}
class Person{
    // 构造代码块
    {
        System.out.println("1.构造代码块");
    }
    // 静态成员
    public static String blood = "白种人";
    static {
        // 静态成员只能访问静态成员，无法访问非静态成员
        System.out.println(blood);
        System.out.println("静态代码块");
    }
    private int age ;
    private String name;
    private String job;
    public int getAge() {
        return age;     
    }
    public void setAge(int age) {
        this.age =age;
    }
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * @return the job
     */
    public String getJob() {
        return job;
    }
    /**
     * @param job the job to set
     */
    public void setJob(String job) {
        this.job = job;
    }
    {
        System.out.println("2. 构造代码块");
    }
}

this 关键字：
特点： this 代表其所在函数所属对象的引用。
换言之：this 代表本类对象的引用。
什么时候使用this 关键字？
当函数内需要用到调用该函数的对象时，就用this 。
this.xxx 
   -----
    指向对象自身的引用，类似成员变量，使用private修饰。
    静态方法不可以使用this 
----
this()
   -----
   访问当前类的构造函数
   this()的调用必须是第一条语句。
   为了构造函数的重用。

static (静态)关键字
  1. 用于修饰成员（成员变量和成员函数）
  2. 被修饰后的成员具备一下特点：
     2.1 随着类的加载而加载
     2.2 优先于对象存在
     2.3 被所有对象所共享
     2.4 可以直接被类名调用
  3. 使用注意：
    3.1 静态方法只鞥访问静态成员
    3.2 静态方法中不可以写this，super 关键字
    3.3 主函数式静态的。

package com.learnjava.day04;
public class ClassDemo04 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
     Dog d = new Dog();
     d.setName("小白");
     d.setColor("黄色");
     d.setAge(18);
     System.out.println(d.getName());
     System.out.println(d.getColor());
     System.out.println(d.getAge());
    }
}
class Dog {
    private String name ;
    private String color;
    private int age ;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public int getAge() {
      return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

package com.learnjava.day04;
public class ClassDemo04 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
     Dog d = new Dog();
     d.setName("小白");
     d.setColor("黄色");
     d.setAge(18);
     System.out.println(d.getName());
     System.out.println(d.getColor());
     System.out.println(d.getAge());
     Dog d1 = new Dog("小红","红色",13);
   //  d1.setName("小绿");
     System.out.println(d1.getName());
     System.out.println(d1.getColor());
     System.out.println(d1.getAge());
    }
}
class Dog {
    private String name ;
    private String color;
    private int age ;
    // 空参数的对象
    public Dog() {
    }
    //带参数的 对象
    public Dog(String name,String color , int age) {
        this.name = name;
        this.color = color;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color ) {
        this.color = color;
    }
    public int getAge() {
      return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

package com.learnjava.day04;
public class ClassBenz {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(Benz.Brand);
        Benz b1 = new   Benz();
        b1.setColor("白色"); 
        System.out.println(b1.getColor());
    }
}
class Benz{
    static String Brand = "BENZ";
    private String color = "黑色" ;
    // 构造代码块
    {
        System.out.println(color);
    }
    public Benz() {
        System.out.println(color);
    }
    public Benz(String color) {
        this();
        this.color = color;
    }
    public Benz(String color , int tires) {
        this (color);
        System.out.println(color);
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}

百钱买百鸡

package com.learnjava.day05;
/**
 * 
 * @author zhangyy
 *  
 *  百钱买百鸡
 *  
 *  公鸡 ：5/只
 *  母鸡： 3/只
 *  小鸡： 1/3只
 *  
 *  100 买100 只鸡
 */
public class BuyChick {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i =0 ; i< 100/5 ; i++) {
            for(int j = 0; j < 100/3 ; j++) {
                for(int k = 0 ; k < 100 ; k = k+3) {
                    int money = i * 5 + j * 3 + (k/3) ;
                    int count = i + j + k ;
                    if (money == 100 && count ==100) {
                        System.out.println("公鸡："+ i + ",母鸡："+ j + ",小鸡：" +k);
                    } 
                }
            }
        }
    }
}

二： Java 的继承

2.1 继承的概述：

1. 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无锡在定义这些属性和行为，只要继那个类即可。
2. 多个类可以称为子类，单独这个类称为父类或者超类。
3. 子类可以直接访问父类中的非私有的属性和行为。
4. 通过extends 关键字让类与类之间产生继承关系。
    4.1 class SubDemo extends Demo{}
5. 继承的出现提高了代码的复用性
6. 继承的出现让类与类之间产生了关系，提供了多态的前提。

2.2 继承的特点：

 1.  java只支持单继承，不支持多继承
     1.1 一个类只能有一个父类，不可以有多个父类
     1.2 class SubDemo extends Demo{}   // ok 
     1.3 class SubDemo extends Demo1,Demo2...// error
     ---
2. java 支持多层继承（继承体系）
    2.1 class A {}
    2.2 class B extends A {}
    2.3 class C extends B {}
3. 定义继承需要注意：
    3.1 不要仅为了获取其他类中某个功能而去继承
    3.2 类与类之间要有所属（"is a "）关系，xx1 是xx2 的一种。
    ----
    继承：
    1. extends
    2. 类 只支持 单从继承
    3. 支持多层继承

package com.learnjava.day04;
public class ExtendDemo06 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Cat c = new Cat();
        c.color = "黑色";
        System.out.println(c.color);
    }
}
class Animal{
    String color;
    int height;
}
class Cat extends Animal {
}

2.3 super 关键字：

super 和this 的用法想象
this 代表本类对象的引用
super 代表父类的内存空间的标示
当　子付类出现同名成员时，可以用super 进行区分
子类要调用父类构造函数时，可以使用super 语句。
----
1.访问超类的构造函数
2. 必须是第一行代码
3. 构造函数的首行要么是this(),要么是super(); 默认是super()

package com.learnjava.day05;
public class ExtendsAnimal {
              public static void main(String[] args) {
                  Jing8 J = new Jing8(null);
                  J.age = 18;
                    System.out.println(J.age);
                    System.out.println(J.color);    
            }
}
class Animal{
    String color;
    String name;
    int age ;
    public Animal(String color) {
        this.color = color;
    }
}
class Dog extends Animal {
    public Dog(String color) {
        super("white");
        // TODO Auto-generated constructor stub
    }
    }
class Jing8 extends Dog {
    public Jing8(String color) {
        super(color);
        // TODO Auto-generated constructor stub
    }
}

2.4 函数的覆盖：

1. 子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写
２.父类中的私有方法不可以被覆盖。
３.在子类覆盖方法中，继续使用被覆盖的方法可以通过super ,函数名获取。
覆盖注意事项：
　　覆盖时，子类方法权限一定要大于等于父类方法权限
　　静态只能覆盖静态。
　　
覆盖的应用：
　　当子类需要父类的功能，二功能主题子类有自己特有内容时，可以复写父类中的方法，这样，既沿袭了父类的功能，又定义了子类特有的内容。
　　
　　函数覆盖：
１.overwrite  
    重写
    复写
２.　只有在继承的时候才有重写
３.　private 方法不可以覆盖
　
    类的的成员：
　　成员函数
　　成员变量
　　构造函数
　　构造代码块
　　静态代码块
　　－－－－－－－－
　　　

package com.learnjava.day05;
public class ClassDemo01 {
       public static void main(String[] args) {
        Son s1 = new Son();
        s1.eat();
        s1.run();
        s1.setAsset(100000);
        System.out.println(s1.getAsset());
    }
}
class Father {
    String name ;
   private int asset ;
    public void eat() {
        System.out.println("洗手！！！！！!");
    }
    public void walk() {
        System.out.println("walk......");
    }
    /**
     * @return the asset
     */
    public int getAsset() {
        return asset;
    }
    /**
     * @param asset the asset to set
     */
    public void setAsset(int asset) {
        this.asset = asset;
    }
}
class Son extends Father{
    public  void eat() {
        //super.eat();
        System.out.println("洗澡！！！！！！");
    }
    public void run() {
        super.walk();
        this.walk();
        System.out.println("run......");
    }
     public void walk() {
    }
}

2.5 子类的实例化过程：

1. 子类中所有的构造函数默认都会访问父类中空参的构造函数
2. 因为每一个构造函数的第一行都有一条默认的语句super();
3. 子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的
4. 当父类中没有空参的构造函数时，子类的构造函数必须通过this 或者 super 语句指定要访问的构造函数。

package com.learnjava.day05;
public class ClassDemo03 {
        public static void main(String[] args) {
            Jing8 J = new Jing8();
            J.run();
        }
}
class Animal {
    String category;
    public Animal() {
        System.out.println("new Animail()");
    }
    public void run() {
        System.out.println("run......");
    }
}
class Dog extends Animal {
    String color ;
    public Dog (String c) {
        System.out.println("new Dog()");
    }
}
class Jing8 extends Dog {
    String blood ;
    public Jing8() {
        super("kkkk");
        System.out.println("new Jing()");
    }
}

2.5 final 关键字

final
  1. 最终的。
  2. 修饰类，不能被继承
  3. 修饰方法，不能覆盖
  4. 修饰变量，不能修改，只能赋值一次，常量
  内部类：
  1. 定义在类内部的类称为内部类
  2. 内部类可以在类成员位置上
      编译时产生的类：外部类$内部类名称  如： Benz$Engine.class
  3.内部类还可以在方法内部定义。
     Benz$1Engine.class
     方式出现。
  4. 内部类在访问局部变量时，不能对局部变量进行重新赋值。Java8 已经不需要用final进行修饰。

package com.learnjava.day05;
public class ClassDemo03 {
        public static void main(String[] args) {
            Jing8 J = new Jing8();
            J.run();
//          J.color = "block";
        }
}
class Animal {
    String category;
    public Animal() {
        System.out.println("new Animail()");
    }
    public final void run() {
        System.out.println("run......");
    }
}
 class Dog extends Animal {
    final  String color = "黄色" ;
    public Dog () {
        System.out.println("new Dog()");
    }
}
final class Jing8 extends Dog {
    String blood ;
    public Jing8() {
        System.out.println("new Jing()");
    }
}

package com.learnjava.day05;
public class InnerClassDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
           BaoM b = new BaoM();
           b.run();
    }
} 
class BaoM{
    String color;
    int tires;
    public void run() {
        Engine e = new Engine();
        e.fire();
        System.out.println("run....");
    }
    // 内部类
    class Engine{
        public void fire() {
             System.out.println("fire....");
        }
    }
}

package com.learnjava.day05;
public class InnerClassDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
           BaoM b = new BaoM();
           b.run("key9999");
    }
} 
class BaoM{
    String color;
    int tires;
    public void run(String key) {
        // 内部类
        class Engine{
            public void fire() {
                 System.out.println("key is ready" + key);
                 System.out.println("fire....");
            }
        }
        Engine e = new Engine();
        e.fire();
        System.out.println("run....");
    }
}

2.6 抽象类：

• 2.6.1 抽象类的概述：

抽象类的概述：
  1. 抽象类定义：
    1.1 抽象就是从多个事物中将共性，本质的内容抽取出来。
    如： 狼和狗 共享都是犬科，犬科就是抽象出来的概念
  2. 抽象类：
    Java 中可以定义没有方法体的方法，该方法的具体实现由子类完成。
    该方法称为抽象方法，包含抽象方法的类就是抽象类。
  3. 抽象方法的由来。
   3.1 多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能的定义，并未抽取功能主体，那么只有功能声，没有功能主体的方法为抽象方法。
   如：狼和狗都有吼叫的方法，可是吼叫内容时不一样的，所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。
   抽象类：
      -------
     1. 抽象方法：
        没有函数体的方法，必须使用abstract 修饰
    抽象方法必须在抽象类中
    抽象类不允许实例化
    抽象类有构造函数

• 1. 抽象类的特点：

1. 抽象类和抽象方法必须用abstract 关键字来修饰
2. 抽象方法只有方法声明，没有方法体，定义在抽象类中。
    格式： 修饰符 abstract 返回值类型 函数名（参数列表）；
3. 抽象类不可以被实例化，也就是不可以用new 来创建对象。原因如下：
     3.1 抽象类似具体事物抽取出来的，本身是不具体的，没有对应的实例、
     如： 犬科是一个抽象概念，真正存在的是狼和狗
     3.2 抽象类即使创建了对象，调用很抽象方法也没有意义。
4. 抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所用的抽象方法后才可以创建对象，否则该子类也是抽象类

package com.learnjava.day05;
public class AbstractClassDemo01 {
        public static void main(String[] args) {
          Dog d = new Dog();
          d.cry();
          Cat c = new Cat();
          c.cry();
        }
}
 abstract class Animal {
 // 抽象类
     abstract public void cry();
}
class Dog extends Animal{
    public void cry() {
        System.out.println("汪汪汪。。。。。");
    }
}
class Cat extends Animal{
    public void cry() {
        System.out.println("喵喵喵。。。。。");
    }
}

2.7 Java的修饰符

类修饰符：
public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。
abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。
final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。
friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。
成员变量修饰符：
public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
friendly ，在同一个包中的类可以访问，其他包中的类不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。
方法修饰符：
public（公共控制符）
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。
final，指定该方法不能被重载。
static，指定不需要实例化就可以激活的一个方法。
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

• 非法修饰组合：

private + abstract 
final + abstract

三 java 的接口

3.1 回顾

oop : 
   class 
    类成员
    ----
    构造函数： 和类同名，没有返回值。可以重载
      this(),super(x,s,s,s)
成员变量：private public 
成员函数：
  静态代码块： 类加载时执行
  {}     // 构造代码块
 抽象类：
   ----
   abstract 修饰类，不能实例化。
 抽象方法：
  没有方法体的方法。abstract
  让子类去实现具体细节。
  final 
    final class // 不能继承
    final 方法   // 不能重写
    final 变量   //常量
内部类：
   ----
       定义在类的内部类
         Benz$Engine 
       定义在方法内部：
         Benz$nEngine
JVM 
------
方法区
栈区： -xss 
堆区: -Xmx  -Xms  
非法组合：
abstract + private 
abstract + final 
private  + final // 不是，多此一举的

package com.learnjava.day06;
public class InnerDemo01 {
       public static void main(String[] args) {
         Benz.Engine e = new Benz.Engine();
         e.fire();
    }
}
class Benz{
    private String color;
    private int  tries;
    // 内部类
     static class Engine{
        public void fire() {
            System.out.println("fire.....");
        }
    }
    /**
     * @return the color
     */
    public String getColor() {
        return color;
    }
    /**
     * @param color the color to set
     */
    public void setColor(String color) {
        this.color = color;
    }
    /**
     * @return the tries
     */
    public int getTries() {
        return tries;
    }
    /**
     * @param tries the tries to set
     */
    public void setTries(int tries) {
        this.tries = tries;
    }
}

3.2 接口

interface  接口：
1. 接口中的成员修饰符石固定的
   1.1 成员变量：public static final
   1.2 成员函数：public abstract 
   1.3 发现接口中的都是public 的
2. 接口的出现将“多继承”通过另一种形式体现出来，既“多实现”
接口中的所有方法都是抽象的
接口：最低标准
     降低耦合度，降低交互的程度
     类和接口之间是实现关系
类可以实现多个接口。
3.接口的特点：
  3.1 接口是对外暴露的规则
  3.2 接口是程序的功能扩展
  3.3 接口是出现降低耦合性
  3.4 接口是可以用来多实现
  3.5 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
  3.6 接口与接口之间可以有继承关系

package com.learnjava.day06;
public class InterfaceDemo01 {
        public static void main(String[] args) {
            WomenStar ws = new WomenStar();
            ws.white();
            ws.rich();
            TuHao t = new TuHao();
            t.marry(ws);
            KoreanMan m1 = new KoreanMan();
            t.marry(m1);
        }  
}
// 定义一个接口
interface White {
    //白
    public void white();
}
interface Rich {
    public void rich();
}
// 类实现接口
class WomenStar  implements White,Rich{
    public void white() {
        System.out.println("很白");
    }
    public void rich() {
        System.out.println("有钱");
    }
}
class TuHao {
    // white 是接口
    public void marry(White w) {
        w.white();
    }
}
class KoreanMan implements White {
       public  void  white() {
           System.out.println("白面小生");
       }    
}