面向对象编程
以类的方式组织代码,以对象的方式组织数据。
核心思路:
- 封装
- 多态
- 继承
一、方法
public boolean func (int a, int b){
return a == b;
}
1.1 修饰符
- public
- private
- protected
- static
- final
1.2 分类
- 静态方法
- 非静态方法
静态方法不能调用非静态方法
二、类和对象
类是一个抽象的,对象是具体的。
2.1 构造器
使用 new 关键字,会调用类的构造器进行初始化。
当一个类未定义任何构造器,会存在一个空构造器。一旦定义了一个有参构造,无参构造需要显示定义
多个构造函数的原理就是方法的重载。
三、封装
高内聚,低耦合
类中的数据应该通过操作接口来完成。
public class test {
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
}
四、继承
继承的本质是对一批类的抽象。
Is a
Java 中只有单继承,没有多继承。
如果一个类没有指定父类,系统直接让其继承Object。所以所有类都直接或者间接
继承Object
类。
父类私有的属性或者方法无法被继承。
4.1 super
可以在子类中调用父类的可访问方法以及构造器
super.func(); // 父类方法
super(); // 父类无参构造器
4.2 注意点
- super 调用父类构造器是,必须在第一行
- super 和 this 不能同时调用构造方法
- 类被final修饰之后不能被继承
4.3 方法重写
- 方法名和参数列表必须相同(不相同叫做重载)。
- 父类 private的方法无法被子类重写。
- 修饰符:范围可以扩大。
- 通过 static、private、final修饰的方法无法被重写
五、多态
父类的引用可以指向子类,方法的调用与引用类型有关。
public class Test{
public static void main(String[] args) {
B b = new B();// 能调用自己或者继承来自父类的方法。
b.test();
A a = new B(); // 可以指向子类,但是不能调用子类独有的方法。
a.test();
a.name; // Error!! not found
}
}
class A {
public void test(){
System.out.println("A->test");
}
}
class B extends A {
public String name;
public void test(){
System.out.println("B->test");
}
}
六、类型转换
使用 instanceof
判断对象和类之间的关系;
assert son instanceof Son;
assert son instanceof Father;
assert son instanceof Object;
assert son instanceof Brother; // Error
子类转父类自动转换,会丢失一些子类特殊方法。
父类转子类强制转换,方便方法的调用,减少重复的代码。
public class Test{
public static void main(String[] args) {
B b = new B();
A a = b; // 自动类型转换
a.say(); // B say something,如果 B 没有重写 say,则输出 A say something。
}
}
class A {
public void say(){
System.out.println("A say something");
}
public void test(){
System.out.println("A->test");
}
}
class B extends A {
public String name;
@Override
public void test(){
System.out.println("B->test");
}
public void say(){
System.out.println("B say something");
}
}
七、Static 关键字
静态变量在内存中只存在一个,能够被多个类的实例化共享。
静态成员变量和方法都可以直接用类.func
进行调用
静态方法只调用静态方法和静态变量。
静态代码块在类加载时就会执行。
// 静态导入包
import static xx.xx.xx.func
八、抽象类
抽象类是抽象的抽象
public abstract class Action{
public abstract void func();
}
public class Something extends Action{
@Override // 必须实现,除非子类也是抽象的
public abstract void func(){
}
}
// 子类也是抽象时不需要实现父类的抽象方法
抽象类不能被实例化(接口同)
九、接口
面向接口编程
接口中只有方法的申明,就像契约、约束。
public interface UserService{
(public abstract final) double PI = 3.14;
(public abstract) void add(int i);
(public abstract) void plus(int i);
}
public class UserServiceImpl implements UserService{
// 实现了接口的类必须实现所有方法
@Override
public void add(int i);{
}
@Override
public void plus(int i);{
}
}
接口可以多继承,不能被实例化
十、内部类
public class Outer{
public class Inner{
}
}
内部类可以获取外部类私有属性和私有方法。
静态内部类可以获取外部类的静态属性和方法
10.1 局部内部类
public class Outer{
public void func(){
public class Inner{
}
}
}
10.2 匿名内部类
new UserService(){
@Override
public void add(int i);{
}
@Override
public void plus(int i);{
}
}