Java的核心思想就是OOP(Object-Oriented Programming,面向对象编程)
面向对象
一、三大特点:
- 封装
- 继承
- 多态
二、创建与初始化对象:
- 使用new关键字创建对象的时候,除了分配内存空间,还会给创建好的对象进行默认的初始化以及调用类中的构造器
- 类中的构造器也叫构造方法,是在进行new对象时必须要调用的,new的本质就是在调用构造方法
- 构造器有两个特点:必须和类名相同;必须没有返回类型,也不能写void
- 如果定义了有参构造,想要调用无参构造时,那么必须显示无参构造
- idea开发工具里面有个快捷键:Alt+Insert ,可以生成有参或无参构造方法
三、封装:
- 高内聚,低耦合:高内聚就是类的内部数据操作由类自己完成,不允许外部干涉;低耦合就是暴露少量的端口给外部使用
- 应禁止直接访问对象中数据的实际表示,应通过操作接口来访问
- 属性私有,使用private修饰属性(字段)
四、继承(extends):
- Java中只有单继承,没有多继承
- 继承是类和类之间的关系;除此之外,类和类之间的关系还有依赖、组合、聚合等
- 继承关系的两个类,一个是子类(派生类),一个是父类(基类);子类继承父类,通过关键字extends实现;父类里面私有的属性及方法是不能被继承的
- Java中所有的类都默认直接或间接继承Object类
五、super:
- super和this区别:this表示当前类,super表示当前类的父类;this没有继承也可以使用,super只能在继承时才能调用
- super必须只能出现在子类的方法或构造方法中
- 子类继承父类时,子类的构造方法会默认调用父类的构造方法,并且父类的构造方法必须在子类构造方法的第一行(默认是隐藏的)
- super和this不能同时调用构造方法
六、重写(override):
- 重写是方法的重写,与属性无关
- 重写的前提:需要有继承关系,子类重写父类的方法
- 方法名称必须相同,参数列表必须相同,方法体不同
- 修饰符的范围可以扩大但不能缩小:public>protected>default>private
- 抛出的异常的范围可以缩小但不能扩大
- 不能被重写的方法:static修饰的方法,static修饰的方法属于类,不属于实例;final修饰的方法;private修饰的方法;
七、多态:
- 多态存在条件:有继承关系;子类重写父类方法;父类引用指向子类对象
- 多态是方法多态,属性没有多态
- 子类转为父类,不需要强制转换;父类转换为子类,需要强制转换
- instanceof(引用类型转换): x instanceof y;x和y必须要有联系,它们两个之间是父子关系;若没有联系,编译就会报错
- 当前类中,非静态方法可以调用静态方法,但静态方法不能调用非静态方法
- 通过final修饰的类是不能被继承的,是没有子类的
public class Person {
{
// 代码块(匿名代码块):在创建Person对象的时候创建的,在构造器之前
System.out.println("匿名代码块");
}
static{
// 静态代码块
System.out.println("静态代码块");
}
public Person() {
System.out.println("构造器代码块");
}
public static void main(String[] args) {
Person person = new Person();
System.out.println("================");
Person person1 = new Person();
}
}
// 执行main方法,输出结果为:
静态代码块
匿名代码块
构造器代码块
================
匿名代码块
构造器代码块
// 静态代码块只执行一次
八、抽象类:
- 由abstract修饰符修饰
- abstract可以修饰类,修饰的类叫抽象类;也可以修饰方法,修饰的方法叫抽象方法;
- 抽象类中可以没有抽象方法,但是有抽象方法的类必须声明为抽象类
- 抽象类不能使用new关键字来创建对象,它是需要子类来实现的
- 抽象方法:只有方法的声明,没有方法的实现,需要子类来实现
- 子类继承抽象类,必须要实现抽象类没有实现的抽象方法,否则子类也需要声明为抽象类
// 抽象类
public abstract class Person {
// 抽象方法:之后方法名,没有方法的实现
public abstract void eat();
}
public class Student extends Person{
// 抽象类的所有方法被其子类所实现,除非子类也是抽象类,则不需要实现方法
@Override
public void eat() {
System.out.println("吃饭!");
}
}
九、接口:
- 类由class关键字声明;接口由interface关键字声明
- 普通的类只有具体的实现;抽象类有具体实现也有抽象方法(规范);接口只有抽象方法(规范)
- 在接口里面,方法默认是public abstract修饰的,属性默认是public static final修饰的
- 接口都需要实现类,通过implements关键字
- 实现了接口的类,必须要重写接口里面的所有方法
- 一个类可以实现多个接口
- 接口中没有构造方法
// 接口
public interface Cat {
void run();
}
public interface Dog {
void jump();
}
// 接口的实现类
public class PetImpl implements Cat,Dog {
@Override
public void run() {
System.out.println("跑");
}
@Override
public void jump() {
System.out.println("跳");
}
}
十、内部类:
- 内部类就是在一个类内部再定义一个类;A类里面定义了一个B类,那么B类就是A类的内部类,而A类就是B类的外部类
- 内部类分为:成员内部类、静态内部类、局部内部类、匿名内部类
- 静态内部类是无法访问外部类的非静态属性的
- 一个java类中,只能有一个public class类,但可以有多个class类
public class Outer {
private int id;
public void out(){
System.out.println("外部类方法");
// 局部内部类:在方法里面定义的类
class partInner{
}
}
// 成员内部类
public class Inner{
public void in(){
System.out.println("内部类方法");
}
// 获取外部类的私有属性
public void getId(){
System.out.println(id);
}
}
// 静态内部类
public static class Inner01{
}
}
public class Demo1 {
public static void main(String[] args) {
Outer outer = new Outer();
// 通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.getId();
// 匿名内部类,不用将实例保存到变量中
outer.new Inner().getId();
}
}