面向对象

面向对象的基本思想是，从现实世界中客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用人类的自然思维方式。

面向对象更加强调运用人类在日常德思维逻辑中经常采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

对象用计算机语言对问题域中事物的描述，对象通过“属性（attribute）”和“方法（method）”来分别对应事物所具有的静态属性和动态属性。

Java与面向对象

对象是java的程序的核心，在java程序中“万事万物皆对象”。

对象可以看成是静态属性（成员变量）和动态属性（方法）的封装体。

类是用来创建同一类型的对象的“模板”，在一个类中定义了该类对象所具有的成员变量以及方法

为什么用对象：

Java类的定义

变量一般定义：声明---->赋值

成员变量

成员变量可以是Java语言中任何一种数据类型（包括基本类型和引用类型）
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
成员变量的作用范围为整个类体

局部变量：

局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。
局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。
局部变量没有默认初始化值

class Person{

　　//成员变量定义

　　private int id;//因为是成员变量，所以默认初始化

　　private int age = 20;

     //方法定义

     public int getAge() {return age;}

　　public void setAge(int i){age = i;}

　　public int getId() {return id;}

}

对象的创建和使用

构造方法

使用new +构造方法创建一个新对象。
构造函数是定义在Java类中的一个用来初始化对象的函数
构造方法与类同名没有返回值

public class void Person {

　　int id;

　　int age;

　　Person(int n,int i){

　　id = n;

　　age = i;

}

}

this关键字

在类的方法中定义中使用的this关键字代表使用该方法的对象的引用

当必须指出当前使用方法的对象是谁时要使用this

有时使用this可以处理方法中成员变量和参数重名的情况

this可以看作是一个变量，它的值是当前对象的引用

public class Leaf {

　　　　int i = 0;
　　　　Leaf (int i) {

　　　　this.i = i ;

  　　　　}
        Leaf increament(){  //返回值为 leaf类型this(对象)

     　　i++;

           return this;

        }

　　　　....

        
}

static关键字

在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，第一次使用时被初始化。对于该类所有对象来说，static成员变量只有一份。
用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。

静态的方法不再是针对于某个对象调用，所以不能访问非静态成员。

可以通过对象引用或类名（不需要实例化）访问静态成员。

public class Cat {
   
    private static int sid = 0;//static 
    private String name; 
    int id;
    Cat(String name) {
        this.name = name;  
        id = sid++;
    }
    public void info(){
        System.out.println
               ("My name is "+name+" No."+id);
    }
    public static void main(String arg[]){

        Cat.sid = 100;
        Cat mimi = new Cat("mimi");
        mimi.sid = 2000;
        Cat pipi = new Cat("pipi");
        mimi.info(); 
        pipi.info();
    }
}

super关键字----引用基类的成分

class FatherClass{
    public int value;
    public void f(){
        value = 100;
        System.out.println("Fater's value="+value);
    }
}
class ChildClass extends FatherClass{
    public int value;
    public void f(){
        super.f();
        value = 200;
        System.out.println("child's value="+value);
        System.out.println(value);
        System.out.println("Fater's value="+super.value);
    }
}
public class SuperTest {
    public static void main(String[] args){
        ChildClass cc = new ChildClass();
        cc.f();
    }
}

动态绑定和多态

动态绑定是指“在执行期间（而非编译期）判断所引用对象的实际类型，根据其实际类型调用其相应的方法”

多态的存在有三个必要条件：

1、要有继承

2、要有重写

3、父类引用指向子类对象。

抽象类

用abstract修饰一个类时，类就是抽象类；用abstract修饰一个方法时，该方法就是抽象方法
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写
抽象类不能实例化
抽象方法只需声明，而不需实现

abstract class Animal{
    private String name;
    Animal(String name){
        this.name = name;
    }
    public abstract void enjoy();
    //public abstract void enjoy();
}
class Cat extends Animal{
    private String eyesColor;
    Cat(String n,String c){
        super(n);
        eyesColor = c;
    }
    public void enjoy(){   //抽象类必须得重写，如果不重写，cat不能实例化
        System.out.println("猫叫声");
    }
}

class Dog extends Animal{
    private String furColor;
    Dog(String n,String c){
        super(n);
        furColor = c;
    }
    public void enjoy(){
        System.out.println("狗叫声");
    }
}

class Lady {
    private String name;
    private Animal pet;
    Lady(String name, Animal pet){
        this.name = name;
        this.pet = pet;
    }
    public void myPetEnjoy(){
        pet.enjoy();
    }
}
public class TestPoly {
    public static void main(String[] args){
        Cat c = new Cat("catname","blue");//创建一个cat对象
        Dog d = new Dog("dogname","black");//创建一个Dog对象
        Lady l1 = new Lady("l1",c);//创建lady对象并让Cat向上转型
        Lady l2 = new Lady("l2",d);//创建lady对象并让Dog向上转型
        
        l1.myPetEnjoy();//调用cat
        l2.myPetEnjoy();//
    }
}

接口

接口（interface）是抽象方法和常量值得定义的集合

本质上讲，接口是一种特殊的抽象类，这种抽象类中包含常量和方法的定义，而没有方法的定义，而没有变量和方法的实现

接口定义举例：

public interface Runner {
       public static final int id = 1;//修正C++多继承易出现问题
     
       public void start();
       public void run();
       public void  stop();         
}

接口特性

接口可以多重实现
接口成员变量的默认属性默认为public static final；
接口中只能定义抽象方法，而且这些方法默认为public，也只能是public
接口可以继承其它的接口，并添加新的属性和抽象方法

接口的实现

interface Singer {
     public void sing();
     public  void sleep();
}

class Student implements Singer {
       private String name;
       Student (String name){
             this.name = name;
      }
       public   void study() {
             System.out.println("studying");
       }
       public String getName(){
             return name;
       }
        public   void sing() {
             System.out.println("student is singing");
       }
        public   void sleep() {
             System.out.println("student is sleeping");
       }
}