面向对象基础知识学习总结笔记2019-8-26

什么是类?具有相同属性和行为(或者叫功能)的对象的抽象的集合
———————————————————-

类的实例化;
   实例—就是一个真实的对象.
   实例化就是创建对象的过程，使用new关键字来创建。

Cat cat = new Cat();
Cat cat ;声明一个Cat的对象，对象名为cat
cat = new Cate();将cat对象实例化

    
构造方法,又叫构造函数，其实就是对类进行初始化。
构造方法和类名仙童，不需要void，在new时候调用

pubic class Cat{

    
    public String name”咪咪”;//默认的名字为咪咪
    public String color;

    public Cat(){

        //无参构造
    }
    //有参构造
    public Cat(String name,String color){

    this.name = name;
    this.color = color;
    }

}

如果不变吗构造方法，
系统会默认生成一个无参构造方法，如果编码就会把无参构造方法覆盖掉。
构造方法的目的就是为了初始化类，实例化对象

Cat cat = new Cat();
或者
Cat cat = new Cat(“咪咪”,”白色”);

构造方法也是方法的一种.

————————————————————————-
方法重载():方法名相同，方法列表不同(包含了参数个数和类型不同);方法重载和返回值没有关系；

    可以在不改变原方法的基础上，新增功能。

方法的重载对函数(或者叫方法)提供了扩展的能力。

pubic class Cat{

    
    public String name”咪咪”;//默认的名字为咪咪
    public String color;

    public Cat(){

        //无参构造
    }
    //有参构造
    public Cat(String name,String color){

    this.name = name;
    this.color = color;
    }

    public void setName(String name){

    this.name = name;
    }
    public String getName(){

    return name;
    }

    public void setColor(String color){

    this.color = color ;
    }
    public String getColor(){

    return color;
    }

}

无参构造方法和有参构造方法，就可以被叫着方法重载(Overload)。

set/get第一个字母小写，比如name,color 叫javabean属性。

封装的好处——-减少耦合;
封装理解成一个房屋，
    房屋的门窗，就是封装对象暴露在外的属性和方法，专门工人进出，以及流通空气、带来阳光.
    在房屋内部我们可以随意摆设和修改而不用影响他人。

public class Cat{

    private String name;//名称
    private Integer callNum;//叫的次数
    
    public Cat(){}

    public Cat(String name,Integer callNum){

    this.name = name;
    this.callNum = callNum;
    }

        public void setName(String name){

    this.name = name;
    }
    public String getName(){

    return name;
    }

    public void setCallNum(Integer callNum){

    this.callNum = callNum;
    }
    public Integer getCallNum(){

    return callNum;
    }

    public String short(){

    String result = “”;
    for(int i = 0;i<=callNum;i++){

        result +=”喵”
    }
    
    return “我的名字”+name+result;
    }    
    
}

——————-继承

  对象继承的关系是is-a;继承定义了类如何相互关联、共享特性。

  继承的工作方式，定义父类和子类，或者叫基类和派生类。
 
  其中子类继承父类所有特性,子类不但继承了父类的所有特性，还可以定义新特性。

——子类继承父类:
    1.子类继承父类，子类拥有父类非private的属性和功能(方法);
    2.子类具有自己的属性和功能(子类可以扩展父类的属性和功能)
    3.子类还可以自己的方式实现父类的功能(方法重写rewrite)

修饰符private / public

protected表示进程时子类可以对基类有完全访问权。也就是说对子类公开，但不低其他类公开.

private – public – protected三者的区别

public 可以在当前类  / 同一package / 子孙类 / 其他package都可以使用
private 只能在当前类中使用
protected 可以在当前类/同一package/子孙类 使用.

子类的构造方法中默认调用父类的构造方法使用关键字super()/super.属性名;默认在构造方法体中的第一行中

及时每写默认也有，目的是为了初始化父类相关属性。

继承的优点:把子类公共的部分都放在父类上，使得代码得到共享，避免重复;另外,继承可使得修改或扩展继承而阿里的实现都较为容易

缺点就是耦合度太高。不便于解耦。父类变了，子类也不得不变。

——————多态(一类事物多种形态)
不同对象可以执行相同的动作,需要通过他们自己的实现代码来执行。

多态:
    1.子类以父类的身份出现
    2.子类在工作时以自己的方式来实现
    3.子类以父类的身份出现时,子类特有的属性和方法不可以使用。

方法重写override  将父类实现替换为自己的实现.

public class Animal{

    String name;
    String call;

    //set/get方法

    public abstract void shout();
}

public class Cat extends Animal{

    
    public void shout(){

    System.out.println(“cat 喵喵叫”);
    }
}

Animal animal = new Cat();
animal.shout();

多态的原理是当方法被调用时，无论对象是否被转换为其父类，都只有位于对象继承链最末端的方法实现会被调用。

多态存在三个必要条件:
    1.继承
    2.重写
    3.父类的引用指向子类对象
Animal animal = new Cat();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；
如果有，再去调用子类的同名方法。

多态调用方法—-[编译看左边,运行看右边]

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

abstract class Animal {  
    abstract void eat();  
}  
 
class Cat extends Animal {  
    public void eat() {  
        System.out.println(“吃鱼”);  
    }  
    public void work() {  
        System.out.println(“抓老鼠”);  
    }  
}  
 
class Dog extends Animal {  
    public void eat() {  
        System.out.println(“吃骨头”);  
    }  
    public void work() {  
        System.out.println(“看家”);  
    }  
}

public class Test {

    public static void main(String[] args) {

      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {

      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。

要想调用父类中被重写的方法，则必须使用关键字 super。

多态的实现方式：
    方式一:重写
    方式二:接口
    方式三: 抽象类和抽象方法

多态引用时，构造子类对象时的构造方法的调用顺序

1，先调用超类的构造方法，多重超类首先调用最远超类的方法；

2，然后再执行当前子类的构造方法；

调用时需要谨慎处理调用方法

————————–抽象类

使用abstract修饰的类被称为抽象类;修饰方法为抽象方法(抽象方法不能有方法体)

注意:
  1.抽象类不能实例化

  2.抽象方法必须被子类重写的方法.

  3.有抽象方法的类必须为抽象类，反之则不然。
   抽象类中可以有抽象方法，也可以没有抽象方法.

抽象类拥有尽可能多的共同代码。

什么时候使用抽象类?
    抽象类作为一个抽象的概念,它提供了一个继承的触发点，
    当设计一个新的抽象类时，一定是用来继承的。
    所有在一个以继承关系行成的等级结构里面。
    树叶节点应当为一个具体类，而树枝节点均应当是抽象类.
    具体类不作为继承的。

————————–接口(interface)

接口不能被实例化，没有构造方法;
接口的中所有方法必须是抽象方法;
接口不能包含成员变量,处理static和fianl变量
接口只能被实现，不能被继承

在java中单继承，多实现。

接口特点:
   1.接口方法默认会加上public abstract
   2.接口中的变量默认会加上public static final修饰.

抽象类和接口的区别

    1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
    
    2. 抽象类中的成员变量可以是各种类型的，
       而接口中的成员变量只能是 public static final 类型的。
    
    3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，
    而抽象类是可以有静态代码块和静态方法。
    
    4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

    注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

接口可以多继承接口:public interface IHockey extends ISports, IEvent{  }

接口的命名,前面要加一个代谢字母”I”

接口，特有的功能可以放在接口，谁有这种特种的功能，谁就去实现该接口。

类是对对象的抽象;抽象类是对类的抽象;接口是对行为的抽象.

接口是对类的局部行为进行的抽象,而抽象类是对类整体(比如字段、属性、方法)的抽象.
如果只关注行为抽象，那么也可以认为接口是抽象类.

如果行为跨越不同类的对象，可以使用接口;对于一些相似的类对象，用继承抽象类。
    实现接口和继承抽象类并不冲突。让超人继承人类，再实现飞行接口。

抽象类是从子类中发现了公共的东西,泛化出父类,
    然后子类继承父类,而接口是根本不知子类存在,
    方法如何实现还不确认，预先定义。
    （通过重构改善既有代码的设计）
    抽象类往往都是通过重构得到来的。
    
    抽象类是自底而上抽象出啦，接口则是自顶向下设计出来的。
      （学习GOF23种设计模式更好理解抽象类和接口）

—————————集合（Collections）

集合、数组理解成容器用于存放数据。
    有些容器可以自动扩展，有些容器的容量是固定好的。
    
    往容器里面放入数据，可以按照顺序放入，也可以选择不按照顺序放入。

数组在内存中连续存储,可以快速而容易地从头到尾遍历元素、修改元素.
缺点就是数组一旦指定大小，就不能发生改变。同时在两个元素之间添加元素也比较困难。

数据结构:堆栈、队列、列表、哈希表、红黑树等数据结构。

ArrayList

java中的自动装、拆箱。比如整数类型默认为int类型。小数默认为double类型

—————————泛型
我认为泛型就是进行限定类型。如何定义泛型类和方法?

public class BaseResult<T>{

    T item;

    public void setData(T t){

    this.item = t;
    }

    public T getData(){

    return this.item;
    }

    //泛型方法
    public <E> void printInfo(E e){

    System.out.prinlnt(e);
    }
    
}