目录
一、类
类，就是模板，用来定义一类对象的方法和属性。比如人，动物都可以定义为类。
还有就类名首字母大写。
二、对象
类的一个实例化，就比如书籍的一个实例化，就是某本书。
三、方法
方法就是语句的一个集合，在一起实现一个功能。
方法包含于类或者对象中，即普通方法或者类方法。
其大致模样如下，
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
方法又可以分为有参构造和无参构造
无参构造函数
public 类名(){
//写⾃定义的语句
}
有参构造函数
public 类名(参数类型1 参数名1，参数类型2 参数名2...){
//⾃定义⽅法体
}
构造函数的修饰符
public ⽤的最多，⽤来创建对象。
private 私有化构造函数，不给外部创建对象，⽐如⼯具类，或者单例设计模式。
default 默认的话，只能在当前包⾥⾯使⽤new 创建对象，⼏乎不⽤。
四、封装
什么是封装？
封装把对象的所有组成部分组合在⼀起，封装定义程序如何引⽤对象的数据
封装实际上使⽤⽅法将类的数据隐藏起来，控制⽤户对类的修改和访问数据的程度。
适当的封装可以让代码更容易理解和维护，也加强了代码的安全性
包括：类封装、⽅法封装
案例（把书籍的一些属性进行封装）：
五、继承
子类继承父类的特征和行为，使得子类对象具有父类的方法和属性。
父类也叫基类，具有公共的方法和属性。
动物<—猫
动物<—狗
格式：通过extends关键字
class ⽗类名称{
}
class ⼦类名称 extends ⽗类名称{
}特点：
⼦类拥有⽗类的⾮private的属性和⽅法。
⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法 override(重写，覆盖)。
实现了代码的复⽤，重写从⽗类那⾥继承来的⽅法的，当调⽤⽅法时候会优先调⽤⼦类的⽅ 法（默认就近原则）。
构造方法和继承：
⼦类不能继承⽗类的构造⽅法，但⼦类在创建对象时会⾃动调⽤⽗类的构造⽅法（如果⽗类 有默认构造⽅法）。
如果⽗类没有⽆参数的构造⽅法，⽽⼦类构造⽅法中⼜没有显式调⽤⽗类的构造⽅法，则编 译会出错。
⼦类可以通过 super() 关键字显式调⽤⽗类的构造⽅法，且 super() 调⽤必须位于⼦类构造⽅ 法的第 ⼀⾏。
class Animal {
void eat() {
System.out.println("Animal eats"); }
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
// 覆盖⽗类的sound⽅法
@Override
void sound() {
System.out.println("Dog barks");
}
// 新增⽅法
void fetchBall() {
System.out.println("Dog fetches a ball");
}
}
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.eat(); // 调⽤⽗类的eat⽅法
myDog.sound(); // 调⽤⼦类覆盖后的sound⽅法
myDog.fetchBall(); // 调⽤⼦类新增的fetchBall⽅法
}
注意
不⽀持多继承，⽀持多重继承，多重继承提⾼了耦合性，组合优于继承
所有的类都是继承于 java.lang.Object
final关键字
修饰的类，则这个类不可以被继承
修饰⽅法，则这个⽅法不允许被覆盖（重写）
java继承后类的初始化顺序
问题：静态代码块、⾮静态代码、⽗类/⼦类⽆参构造⽅法、⽗类/⼦类的⼀般⽅法
public class Father {
static {System.out.println("⽗类静态代码块");
}
public Father(){
System.out.println("father ⽆参构造函数");
}
public Father(int age){
System.out.println("father 有参构造函数");
}
public void sleep(){
System.out.println("father sleep⽅法");
}
}
public class Children extends Father{
static {
System.out.println("Child静态代码块");
}
public Children(){
//super();
System.out.println("Child⽆参构造函数");
super.sleep();
}
public void sleep(){
System.out.println("Child sleep⽅法");
}
}
public static void main(String[] args) {
new Children().sleep();
}
六、多态
1.多态指的是同一个行为具有多个不同的表现形式的能力。
2.一般是继承或者重写方法实现。
3.优点：减少耦合、灵活可拓展。
七、抽象
1.关键词abstract声明的类叫作抽象类，abstract声明的⽅法叫抽象⽅法
2.⼀个类⾥包含了⼀个或多个抽象⽅法，类就必须指定成抽象类
3.抽象⽅法属于⼀种特殊⽅法，只含有⼀个声明，没有⽅法体
格式：
//抽象类
abstract class 类名{
}
//抽象⽅法，不能有⽅法主体
abstract 返回类型 ⽅法名();案例：
public abstract class Vehicle {
public abstract void run();
public void stop(){System.out.println("停在路上");
}
}
class Bicycle extends Vehicle{
@Override
public void run() {
System.out.println("⼈⼯驱动");
}
}
class Automobile extends Vehicle{
@Override
public void run() {
System.out.println("汽油驱动");
}
}
特点：
抽象特点：
抽象类的特点
抽象类不能被实例化，因为抽象类中⽅法未具体化，这是⼀种不完整的类，所以不 能直接实例化， 编译⽆法通过.
抽象类中不⼀定包含抽象⽅法，但是有抽象⽅法的类必定是抽象类。
如果⼀个抽象类中可以没有抽象⽅法，这样做的⽬的是为了此类不能被实例化。
抽象类的⼦类必须给出抽象类中的抽象⽅法的具体实现，否则⼦类也是抽象类，需 要⽤abstract声 明。
抽象类不能使⽤final关键字修饰，因为final修饰的类是⽆法被继承。
抽象⽅法的特点
抽象类中的抽象⽅法只是声明，不包含⽅法体。
抽象⽅法不能⽤private修饰，因为抽象⽅法必须被⼦类实现（覆写），⽽private权限对 于⼦类来 说是不能访问的。
⼀个类继承了⼀个抽象类，那么它必须全部覆写抽象类中的抽象⽅法当然也可以不全部 覆写。
如果不覆写全部抽象⽅法则这个⼦类也必须是抽象类 构造⽅法，类⽅法（即static 修饰 的⽅法）不能声明为抽象⽅法。
八、重载、重写
1.重载
在一个类里面，方法名相同，参数不同和返回类型无关。
重载与方法的访问修饰符是否是static无关。
2.重写
⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写, 返回值和形参都不能改变。
包括：返回值类型，⽅法名，参数类型以及个数。
⼦类能够根据需要实现⽗类的⽅法。
案例如下:
九、this关键字的用法与指向
在Java中， this 是⼀个特殊的引⽤变量，它引⽤当前对象本身。
在类的内部，你可以使⽤ this 来引⽤对象的当前实例的变量和⽅法。
this关键字的主要用途有：
区别成员变量和局部变量：
public class ThisExample {
private int x; // 成员变量
public ThisExample(int x) {
this.x = x; // 使⽤this引⽤成员变量x，并将参数x的值赋给成员变量x
}
public void printX() {
System.out.println("Value of x: " + this.x); // 使⽤this引⽤成员变量x
}
}
在构造方法中引用其他构造方法通过this()
public class ThisExample {
private int x, y;
public ThisExample(int x) {
this(x, 0); // 调⽤另⼀个构造⽅法
}
public ThisExample(int x, int y) {
this.x = x; // 成员变量x
this.y = y; // 成员变量y
}
public void printXY() {
System.out.println("x = " + x + ", y = " + y);
}
}注意事项：
this 不能在静态⽅法中使⽤，因为静态⽅法不属于类的任何实例。
this 引⽤的是当前对象的内存地址，⽽不是它的值。
this 只能在构造⽅法或实例⽅法中使⽤，不能在类⽅法中（静态⽅法）使⽤。
如果在构造⽅法中没有显式地使⽤ this 来调⽤另⼀个构造⽅法，则会⾃动调⽤⽆参数的构造 ⽅法（如 果存在） 但如果在构造⽅法中已经使⽤了 this() 来调⽤另⼀个构造⽅法，则不能再 调⽤另⼀个构造⽅法或默认 构造⽅法。
十、super关键字
⼀个引⽤变量，⽤于引⽤⽗类对象
⽗类和⼦类都具有相同的命名⽅法，要调⽤⽗类⽅法时使⽤
⽗类和⼦类都具有相同的命名属性，要调⽤⽗类中的属性时使⽤
super也是⽗类的构造函数，格式 super(参数)
注意点 调⽤super() 必须是类构造函数中的第⼀条语句，否则编译不通过
public class Father {
public Father(){
System.out.println("father ⽆参构造函数");
}
}
public class Children extends Father{
public Children(){
//默认存在，写和不写都⾏
super();
System.out.println("Child⽆参构造函数");
}
}this()和super()都指的是对象，均不可以在static环境中使⽤
包括：static变量,static⽅法，static语句块。
十一、接口interface
什么是接口？
是抽象⽅法的集合，接⼝通常以interface来声明，⼀个类通过继承接⼝的⽅式，从⽽来继承接⼝的抽象 ⽅法。
类可以使用implements关键字来实现一个或者多个接口。
案例（Shape 接⼝定义了两个⽅法 draw() 和 calculateArea() ， Circle 和 Rectangle 类分别实现了这两 个⽅法。 在 InterfaceDemo 类中，创建了 Circle 和 Rectangle 的实例，并调⽤了它们的 draw() ⽅法。 由于它们都实现了 Shape 接⼝，因此可以将它们都赋值给 Shape 类型的变量）：
// 定义⼀个接⼝
public interface Shape {
void draw();
void calculateArea();
}
// 实现接⼝的类
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a circle...");
}
@Override
public void calculateArea() {
// 具体的⾯积计算逻辑
}
}
// 另⼀个实现接⼝的类
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a rectangle...");
}
@Override
public void calculateArea() {
// 具体的⾯积计算逻辑
}
}
// 使⽤接⼝的示例
public class InterfaceDemo {
public static void main(String[] args) {
Shape circle = new Circle();
circle.draw();
Shape rectangle = new Rectangle();
rectangle.draw();
}
}
接口和抽象类的区别：
抽象类可以有⽅法的具体实现，⽽接⼝中的⽅法都是抽象的（除了默认⽅法和静态⽅法）。
抽象类可以有构造⽅法，⽽接⼝不能有构造⽅法。
⼀个类只能继承⼀个抽象类，但可以实现多个接⼝。
接⼝主要⽤于定义规范，⽽抽象类主要⽤于代码的复⽤。
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
