对象：一切皆为对象。

对象包括两部分内容：属性（名词形容词），行为（动词）。

对象和对象之间是有关系的。 派生（子类与父类的关系），关联，依赖。

类：对同一类别的众多对象的一种抽象。

类，还是用来生成对象的一种模板，对象是类的一种具体化的表现。

面向对象的三大特性：封装，继承，多态。

　　　　　　一：类的定义：

class 类名{

访问修饰符 成员变量的定义;

访问修饰符 成员函数(方法)的定义;

}

例1：

　　public class Student{

　　public String name;

　　public void score(){

　　System.out.println(name+"的成绩是97分");

}

}

例2：

　　public class Student {

　　private String name;

　　public void setName(String name){

　　this.name=name;

　}
　　public String getName(){

　　return this.name;

}

　　void score(){

　　System.out.println(name+"的成绩是97分");

　　}
}

　　　　　　二：访问修饰符：（4种）

默认的（只能在当前包中被调用）；

protecetd （可以被同类继承中的所有类调用）

private，私有。（只能被当前所在的花括号内的代码访问到，除了这个花括号就访问不到了）；

public ，公共的（可以被所有的累访问到）

　　　　　　三：类的创建：类的实例化：用类来创建对象。

类名 变量名 = new 类名（）；

例如（同上面的函数）：Student s = new student();

　　　　　　四.构造函数：

a.必须与类名相同

b.不能有返回类型。

c.自动被执行。对象new出来的时间自动被执行。

d.一般都是public

例1.因为成员变量是public公用的，所以当我把类实例化之后，我就可以用s.name=“张三”给name赋值，这样在输出时就会输出 张三的成绩是97分

例2.以为成员变量是private私有的，所以当我把类实例化之后，我是没有办法用s.来调用其变量的，但是我可以在Student类里面创建一个setName方法和getName方法，但是这两个方法都必须是实例的，不能是static静态的也不能是private私有的，修饰符必须是可以访问的到的所以我们可以设置成public的。这样我们可以用s.setName和s.getName来进行赋值和取值。

　　　　　　五.类的主方法

主方法是累的入口点，他定义了程序从何处开始：主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。主方法语句如下：

public static void main（String[] args）{

　　方法体

}

主方法是静态的。要直接在主方法中调用其他方法，则该方法也必须静态的；

主方法没有返回值；

主方法的形参为数组。

从这里我们就可以看出来（static是静态成员的关键字，void没有返回类型，main是函数名，String[]形参的数据类型，agrs变量名）；我们是可以更改的。不过这是java中规定的默认主函数，程序一经运行jvm便会自动寻找mian函数病自动调用生成对象。

　　　　　　六.构造函数与成员变量初始化的执行次序？

1.成员变量的初始化最先执行，其次在执行构造函数，所以如果在成员变量和构造函数中对同一变量进行赋值，那么构造函数中的赋值便会覆盖成员变量的赋值！

2.

a.成员变量的定义，如果不赋初始值，会使用默认值。而函数内的局部变量不赋值初始值会出问题。

b.成员变量可以被当前类的所有的成员函数都可以调用。而函数里面的变量只能在当前花括号中可以使用。

3.在给变量赋值时有以下几种赋值方式：

a.直接在成员变量初始化时给其赋值；

public class Book {　　

private String shuHao;
private String shuMing;
private String zouZhe;
private String chuBanShe;
private double dingJia;

}

b.在构造函数中给其赋值；

public class Book {　

　　public Book(){

this.shuHao;
this.shuMing;
this.zouZhe;
this.chuBanShe;
this.dingJia;

}

}

注意：this关键字：当前对象。不是当前类。

c.在构造函数参数中定义，在new函数时进行赋值

public class Book {　

　　public Book(String shuHao，String shuMing，String chuBanShe，double dingJia){

}

}

Book bo=new Book（"0123355","西游记","山东出版社","100.0"）；

重载：

1.函数名相同，参数不同（数量，类型）。这两个函数就形成了重载。所谓的类型不同包括，同是两个String和一个int的构造函数，但是他们的排列位置不同（不是一一对应的那么它也是可以形成重载的）

2.重载只跟函数名和参数有关系。

3.重载了的函数，会自动跟据调用的实参来决定调用哪个函数。（当我在new时，会根据所填的相应的实际参数的数量和类型，自动调用对应的函数）

4.除了构造函数可以重载，普通成员函数也可以重载。（还是2.说的只要函数名相同，参数不同（数量，类型）那么就可以形成重载）

例：（构造函数）这些都是可以形成重载的

        public Book2(){
        this.shuMing="红楼梦";
        this.shuHao=Math.random()*1000+"";
        this.zuoZhe="曹雪芹";
        this.jiaGe=100;
    }

    public Book2(String sm,String sh,String zz,double jg){
        this.shuMing=sm;
        this.shuHao=sh;
        this.zuoZhe=zz;
        this.jiaGe=jg;
    }

    public Book2(String sm,String sh,double jg){
        this.shuMing=sm;
        this.shuHao=sh;
        this.jiaGe=jg;
    }    

例：普通函数

        public void YouHui(){
        this.jiaGe=this.jiaGe*0.9;
    }

    public void YouHui(double dz){
        this.jiaGe=this.jiaGe*dz;
    }

    public void YouHui(double dz,String sm){
        this.shuMing=sm;
        this.jiaGe=this.jiaGe*dz;
    }



      1.       bo.YouHui();
        System.out.println(bo.jiaGe+bo.shuMing);

      2.       bo.YouHui(0.4);
        System.out.println(bo.jiaGe+bo.shuMing);

      3.       bo.YouHui(0.4,"西游记");
        System.out.println(bo.jiaGe+bo.shuMing);    

面向对象：封装（一）：构造函数；类的主方法；权限修饰符；对象的创建