什么是类?具有相同属性和行为(或者叫功能)的对象的抽象的集合
———————————————————-
类的实例化;
实例—就是一个真实的对象.
实例化就是创建对象的过程，使用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);
}
}
发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/100778.html原文链接：https://javaforall.cn
【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛
【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...
