面向对象基础知识学习总结笔记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); } }

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/100778.html原文链接：https://javaforall.cn