「这是我参与11月更文挑战的第13天，活动详情查看：2021最后一次更文挑战」
相关文章
Java随笔记：Java随笔记
-
兄弟萌，我真撑不住了，最近忙的要死，实在没时间写啊！！！！这万年老存稿（水文）都被逼得发出来了！啊！ 1、面向对象概念： 举例：大象装进冰箱。 面向过程：强调的是过程（动作）。 打开冰箱 存储大象 关上冰箱
面向对象：强调的是对象（实体）。冰箱自带打开、存储、关闭等功能。 冰箱打开 冰箱存储 冰箱关闭特点： 面向对象就是一种常见的思想，符合人们的思考习惯。 面向对象的出现，将复杂的问题简单化。 面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。
2、类与对象的关系： 类是拥有相同行为特征对象的一个抽象概念。事物的描述。 对象是类这个抽象概念中事实存在的个体。该类事物的描述。 在java中对象通过new来创建的。
范例：
public class Car {
private int num;//汽车轮子数量
private String color;//汽车车身颜色
public int getNum() {
return num;
}
public String getColor() {
return color;
}
public void setNum(int num) {
this.num = num;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Car{" +
"num=" + num +
", color='" + color + '\'' +
'}';
}
}
主函数{
Car car = new Car();//car就是一个类类型的引用变量，指向了该类的对象
}
匿名对象：当对象方法仅进行一次调用时，就可以简化成匿名对象。
范例：
new Car().getColor();
3、封装（三大特性之一）： 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
将变化隔离。
便于使用。
提高重用性。
提高安全性。
封装原则：
将不需要对外提供的内容都隐藏起。
把属性都隐藏，提供公共方法对其访问。
private:
私有，是一个权限修饰符，用于修饰成员。
私有的内容只在本类中有效。
4、构造函数： 特点： 1）函数名与类名相同。 2）不用定义返回值类型。 3）没有具体的返回值。
作用：
给对象进行初始化。————构建创造对象时调用的函数。
注意：
1）默认构造函数的特点。
创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数，那么类中会有一个默认的空构造函数。如果定义了制定的构造函数，那么类中的默认构造函数就没有了。
2）多个构造函数是以重载的形式存在的。
和一般函数区别：
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。
构造函数：对象创建时，会调用只调用一次。
一般函数：对象创建后，可调用多次。
什么时候定义构造函数呢？
在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中。
5、this关键字： 特点： this关键字代表其所在函数所属对象的引用。即：本类对象的引用。 也就是，哪个对象调用了this所在的函数，this就代表哪个对象。
什么时候使用this关键字呢？
当在函数类需要调用该函数的对象时。
当局部变量和成员变量重名，可以用关键字this来区分。
this调用构造函数时注意：
只能定义在构造函数的第一行，因为初始化动作要先执行。
基本应用：
判断是否为同龄人：
public boolean compare(Person p){
return this.age == p.age;
}
6、static关键字： 主要用于修饰成员（成员变量和成员函数）。
被修饰后的成员具有以下特点：
1）随着类的加载而加载。
2）优先于对象存在。
3）被所有对象共享。
4）可以直接被类名调用。
使用注意：
1）静态方法只能访问静态成员。
2）静态方法中不可以写this、super关键字。
3）主函数是静态的。
成员变量和静态变量的区别？
1） 两个变量的生命周期不一样：
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2） 调用方式不同：
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。
3） 别名不同：
成员变量也被成为实例变量。
静态变量被成为类变量。
4） 数据存储位置不同：
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。
静态变量数据存储在方法区中。（方法区中的静态区）
静态代码块：
随着类的加载而加载，而且只执行一次。
作用：
用于给类进行初始化。因为有的类不需要对象，可直接调用静态代码块。
静态方法和构造方法的区别？
静态方法：随着类的加载而加载，而且只执行一次。
构造方法：是给对应的对象进行针对性的初始化。
构造代码块：可以给所有对象进行初始化。
7、继承（三大特性之二）： java中支持单继承，不直接支持多集成，但对c++中的多继承机制进行改良。 单继承：一个子类只能有一个直接父类。 多继承：一个子类可以有多个直接父类。————不直接支持，是因为当两个父类中有同名的方法时，就会有调用不确定性。 在java中通过多实现的方式来体现它！
java支持多层（多重继承）。
c继承b，b继承a。就会出现继承体系，当要使用一个继承体系时：
查看该体系中的顶层类，了解该体系的基本功能。
创建体系中的最子类对象，完成功能的使用。
好处：
提高了代码的复用性。
让类与类之间产生了关系，给第三个特征多态提供了前提。
什么时候定义继承呢？
当类与类之间存在所属关系的时候，就定义继承。xxx是yyy中的一种，xxx就可以继承yyy的一种。
所属关系： is a 关系。
具体的体现：
在子父类之中：
1）成员变量。
当本类中的成员和局部变量同名重名用this区分。
当子父类中的成员变量同名用super区分为父类。
this和super的区别：
this代表本类对象的引用。
super代表父类的空间。
范例：
calss fu{
int num = 4;
}
class zi extends fu{
int num = 5;
void show(){
sout(this.num + "加" + super.num);
}
}
主函数：{
zi z = new zi();
z.show();
}
打印：4加5
2）成员函数。
当子父类中出现成员函数一模一样的情况下：
会运行子类的函数。这种现象被称为覆盖操作。
函数的两个特性：
1）重载：同一个类中。overload。
2）覆盖（重写）：子类中，覆盖也成为重写（复写）。override。
重写注意事项：
1）子类方法重写父类方法时，子类权限必须要大于等于父类的权限。
2）静态只能重写静态，或被静态重写。
什么时候使用重写操作？
当对一个类进行子类的扩展时，子类需要保留的功能声明，但需要定义子类中该功能的特有内容时，就使用重写操作完成。
范例：
calss fu{
void show(){
sout("old num");
}
}
class zi extends fu{
void show(){
sout("new pic");
sout("new img");
this.show();
}
}
主函数：{
zi z = new zi();
z.show();
}
3）构造函数。
在子类构造对象时，发现访问子类构造函数时，父类也运行了，原因是：在子类的构造函数中，第一行有一个隐式语句。super();————调用父类的构造函数。
子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
8、final关键字 继承弊端：打破了封装性。用final禁止继承。 1）可以修饰类。方法、变量。 2）修饰的类不可以被继承。 3）修饰的方法不可以被重写。 4）修饰的变量是一个常量。只能在初始化时被赋值一次。 为什么要使用final修饰变量？ 如果在程序中有一个数据是固定的，那么直接1使用这个数据就可以了，并且这个变量名称和值不能变化，加上final固定。 写法规范： 常量所有字母都大写，多个单词，中间用 _ 连接。 5）内部类只能访问被修饰的局部变量。
9、抽象类（基于继承）————abstract 抽象：笼统，模糊，不具体。
特点：
1）方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰，抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2）抽象类不可以被实例化。为什么？因为调用抽象方法没有意义。
3）抽象类必须由其子类重写了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。
范例：
abstract calss 犬科{
abstract void 吼叫();
}
class 狗 extends 犬科{
sout("汪汪");
}
class 狼 extends 犬科{
sout("嗷~~嗷~~");
}
提出抽象类的五个问题：
1）抽象类中有构造函数吗？
有，用于给其子类进行初始化。
2）抽象类可以不定义抽象方法吗？
可以，但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。通常这个类中有方法体，但是没有内容。
3）抽象关键字不可以和哪些关键字共存？
private 不行 ———— 因为抽象方法必须被重写。非法修饰符组合。
static 不行 ———— 如果成员变静态，则不需要对象，抽象方法即无意义。
final 不行 ———— 因为无法被重写。
4）抽象类和一般类的异同点？
异： 一般类有足够的信息描述事物。抽象类描述事物的信息可能不足。
一般类中不能第一抽象方法，只能定义非抽象方法。抽象类中可以定义抽象方法，同时可以定义非抽象方法。
一般类可以被实例化。抽象类不可以被实例化。
同：都是用来描述事物的，都在内部定义了成员。
5）抽象类一定是一个父类吗？
一定是父类。
因为某个类继承了抽象类，一定要重写其所有抽象方法才可以对其实例化，否则该类还是抽象类！
10、接口 interface 当一个抽象类中的方法都是抽象方法时，这时候可以将抽象类定义成接口。
格式：
interface {}
接口中的成员修饰符都是固定的：
1）成员常量（全局变量）：public static final
2）成员函数（抽象方法）：public abstract
3）发现接口中的成员都是public的
由此得出结论：接口中的成员都是公共的权限。
接口不再使用继承，使用 implements 来实现接口。
范例：
interface demo{
public static final int num = 4;
void show();
}
calss demoImpl implements demo{
@Override
public void show(){
sout("我是一个接口中抽象方法的实现方法");
}
}
在java中不支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行了改良，在java中变成了多实现。
一个类可以实现多个接口。
范例：
class Test implements 接口一,接口二{
方法体;
}
一个类在继承另一个类的同时，还可以实现多个接口。接口的出现避免了单继承的局限性。
细节：
类与类之间是继承关系。
类与接口之间是实现关系。
接口与接口之间是继承关系。而且接口可以多继承。实现子接口时需重写子接口及所有父接口的所有抽象方法。
特点：
1）接口是对外暴露的规则。
2）接口是程序的功能拓展。
3）接口的出现降低了耦合性。
4）接口可以用来多实现。
5）类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
6）接口和接口之间可以有继承关系。
凡是对外暴露的东西都可以被称之为接口。
接口类与抽象类的异同点？
同：都是不断向上抽取而来的。
异： 1）抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现。
2） 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类区实现。
3） 抽象类的继承是 is a 关系。在定义该体系基本共性内容。
接口的实现是 like a 关系。在定义该体系额外功能。
11、多态 定义：某一种事物的多种存在形态。
例子：父类 名 = new 子类();
动物中猫。狗。
猫这个对象对应的类型就是猫类型。猫 x = new 猫();
同时猫也是动物中的一种们也可以把猫称为动物。动物 y = new 猫();
动物是猫和狗等具体事物中抽取出来的父类型，父类型引用指向了子类对象。
对象的多态性。
猫这类事物即具有猫的形态，又具备着动物的形态。这就是对象的多态性。
简单说就是一个对象对应着不同类型。
多态在代码中的体现：
父类或者接口的引用指向其子类的对象。
路漫漫其修远兮，吾必将上下求索~
如果你认为i博主写的不错！写作不易，请点赞、关注、评论给博主一个鼓励吧~hahah
