Java面向对象

Java面向对象

面向对象编程（Object-Oriented Programming，OOP）

面向对象编程本质：以类的方式组织代码，以对象的组织（封装）数据

三大特性：

1、封装

所谓的封装就是把类的属性和方法使用private修饰，不允许类的调用者直接访问，如果想要操作这些属性使用public的get、set方法。

封装的作用：

• 不直接被外部使用，提高代码的安全性。
• 隐藏代码的实现细节。
• 统一接口，增加系统可维护性。

public class Student{
    //属性私有
    private String name;//姓名
    private int id;//学号
    private char gender;//性别
    
    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法
    
    //get：获取这个数据
    public String getName(){
        return this.name;
    }
    
    //set：给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
}

2、继承（只能单继承）

所谓继承本质就是实现代码的复用，防止重复的代码多次书写，当一个类继承一个类的时候，该类中就会拥有另外一个类中的所有代码，举个例子看下面代码可以看到继承的语法形式是class 子类名 extends 父类名，继承类就是子类，也叫派生类，被继承的类称为父类，基类或者超类（名字一般不做区分，均可使用）。

首先Java是单继承的， 一个子类只能有一个父类，但是一个子类可以当作另外一个类的父类，即可以B继承A，然后C继承B，那么B会拥有A中的代码，C会拥有A、B的代码。

在子类中调用，并使用super关键字，而不是通过实例化对像调用。（super调用父类的构造器，必须要在子类构造器的第一行）（super和this不能同时调用构造方法）

• this：本身调用者这个对象。没有继承也可以用。本类的构造。
• super：代表父类对象的应用。只能在继承条件才可以使用。父类的构造。

当一个普通类继承一个抽象类的时候需要重写抽象类的所有抽象方法，如果不想重写的话就需要声明为抽象类，抽象类是指被abstract修饰，包含抽象方法的类。首先是类名前面添加了abstract关键字，其次是其中包含了一个抽象方法，什么是抽象方法，就是没有被具体实现的方法，没有方法体，并被abstract修饰，不加的话会报错，被abstract修饰的类中可以没有抽象方法，这是语法允许的（jdk1.8测出来的），但是建议同步使用，要么既有abstract修饰类又有abstract方法，要么都没有，注意一点，abstract修饰的类不能直接被实例化。

//在Java中，所有的类，都默认直接或者间接的继承Object类
//Person类：父类
public class Person{
    
}

//Student类：子类，派生类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    
}

//Student类：子类，派生类
//子类继承了父类，就会拥有父类的全部方法
public class Teacher extends Person{
    
}

接口（可以多实现）

首先接口由interface关键字定义，并且其中的所有方法都默认为public abstract的，所有字段都默认为public static final的。实现接口和继承类的一个很大区别就是一个类只能继承一个类，但是一个类可以实现多个接口。

然后类似与继承，接口可以通过implements被实现，实现也很简单，和继承抽象类一样重写所有的抽象方法即可，同样接口不能被直接实例化。

//interface接口的关键字，接口都需要有实现类
public interface UserService{
    //接口中所有定义其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

//interface接口的关键字，接口都需要有实现类
public interface TimeService{
    //接口中所有定义其实都是抽象的public abstract
    void timer();
}

//类可以实现接口implements接口
//实现了接口的类，就需要重写接口中的方法
public class UserSewrviceImpl implements UserService,TimeService{
    //重新UserService中的所有方法
    @Override
    public void add(String name){
        
    }
    @Override
    public void delete(String name){
        
    }
    @Override
    public void update(String name){
        
    }
    @Override
    public void query(String name){
        
    }
    //重新TimeService中的所有方法
    @Override
    public void timer(){
        
    }
}

3、多态

多态是一种思想，是同一份代码，不同的传参（子类）调用会产生不同的效果，绝对不是写死的代码。
多态是建立在继承机制上的一种机制，所谓的向上转型就是使用父类对象的引用，引用子类对象。

重写：

• 方法名必须相同
• 参数列表必须相同
• 修饰符：范围可以扩大但不能缩小：public>protected>default>private
• 抛出异常：范围可以被缩小当不能扩大：ClassNotFoundException --> Exception(大)
• 子类方法和父类方法必须要一致，方法体不同

所谓动态绑定就是使用父类引用引用子类对象然后（向上转型）去调用父类和子类相同的方法（返回值（构成父子类关系也可以，也就是协变类型），方法名、形参列表完全相同）换句话说也就是说在子类中重写了父类的方法，这样的重写需要注意一些点，那就是子类重写的方法的访问权限必须不小于父类的方法的权限也就是说父类为public子类就必须为public因为public是最大的权限，静态方法不能重写，被final修饰的方法（密封方法）不能重写。

instanceof关键字。它是Java中的二元运算符，左边是对象，右边是类。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

//在Java中，所有的类，都默认直接或者间接的继承Object类
//Person类：父类
public class Person{
    public void run(){
        System.out.printf("run");
    }
}

//Student类：子类，派生类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    //重写父类方法
    @Override
	public void run(){
        System.out.printf("son run");
    }
    public void eat(){
        System.out.printf("son eat");
    }
}

public class Application{
    public static void main(String[] args){
        //一个对象的实际类型是确定的
        new Student();
        new Person();
        
        //可以指向的引用类型就不确定了：父类的引用指向子类
        
        //Student能调用的方法都是自己的或者继承的父类的！
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new  Student();
        
        //能执行哪些方法，主要看对象左边的类型，和右边的关系不大！
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
        ((Student) s2).eat();//高转低（需强制转换），才可以使用子类的特有方法
    }
}

回顾方法定义、调用

/*
修饰符 返回值类型 方法名(...){
	//方法体
	return 返回值;
}
*/

静态方法和非静态方法

• 静态方法是在类中使用staitc修饰的方法，在类定义的时候已经被装载和分配。（和类一起加载的）

• public class Person{
      //2、第二个执行（new一次执行一次）
      {
          System.out.printf("匿名代码块");
      }
      
      //1、类加载时第一个执行（只执行一次）
      static{
          System.out.printf("静态代码块");
      }
      
      //3、第三个执行
      public Person(){
          System.out.printf("无参构造方法");
      }
  }
  

• 非静态方法是不加static关键字的方法，在类定义时没有占用内存，只有在类被实例化成对象时，对象调用该方法才被分配内存。（类实例化后才存在）

一、类和对象概念

类是一个抽象的概念，类是一个静态的概念，类本身不携带任何数据。

对象是类的一个具体，对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。

二、对象创建与初始化

• 使用new关键字创建对象（使用new关键字本质是在调用构造器）
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中的构造器的调用。
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有两个特点：
  • 必须和类的名字相同
  • 必须没有返回类型，也不能写void
  • 定义有参构造之后，如果想使用无参构造，显式的定义一个无参构造

public class Person{
    //一个类即使什么都不写，它也会存在一个方法，隐式的定义一个无参构造器
    
    //属性（字段Field 成员变量）
    //语法：修饰符 属性类型 属性名 = 属性值;
    /*	默认初始化：
    	1、数值：0	0.0
    	2、char：u0000
    	3、boolean：false
    	4、引用：null
    */
    String name;
    
    //实例化初始值
    //1、使用new关键字本质是在调用构造器
    //2、用来初始化值
    public Person(){
        System.out.printf("无参构造方法");
    }
    
    //有参构造：一旦定义了有参构造，无参构造必须显式定义
    public Person(String name){
        this.name = name;
    }
    public static void sleep(){
        System.out.printf("我要睡觉了!");
    }

    public static void main(String[] args){
        //对象必须使用new关键字创造对象，构造器
        Person person = new Person();
        //对象的属性
        person.name
        //对象的方法
        person.sleep();
    }
}

对象内存分析