Java面向对象三大特征解析

1 面向对象

1.1 封装

概念：把对象的属性和行为封装起来

优点：隐藏实例细节，便于修改与实现

//构造Person类
public class Person{
    private String name;
    private int age;
    //无参构造
    public Person() {
    }
    //全参构造
    public person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //获取返回值
    public int getAge(){
      return age;
    }
    //获取返回值
    public String getName(){
      return name;
    }
    //设置传入参数类型
    public void setAge(int age){
      this.age = age;
    }
    //设置传入参数类型
    public void setName(String name){
      this.name = name;
    }
}
//调用封装好的Person方法
public class Use {
    public static void main(String[] args) {
        Person c=new Person();//调用方法
        c.setName("无名");//传入参数
        c.setAge(23);//传入参数
        System.out.println(c.getName()+"\n"+c.getAge()+"\n");//获取参数，打印输出
    }
}

1.2 继承

概念：子类继承父类的特征和行为

优点：减少重复代码，且易于维护

//定义父类方法
public class fu {
    void eat(){
        System.out.println("fu吃东西");
    }
}
​
//子类继承父类
public class zi extends fu{
    //继承父类方法，重写输出语句
    void eat(){
        System.out.println("zi喝东西");
    }
    //区分父子类方法
    void something(){
        this.eat();//调用本类方法
        super.eat();//调用父类方法
 }
 //调用方法
    public static void main(String[] args) {
        //子类调用子类方法与父类方法
        zi z=new zi();
        z.eat();
        z.something();
        //子类调用父类方法
        fu f=new zi();//向上转型
        f.eat();
        //zi z=(zi)f//向下转型
    }
}

1.3 多态

概念：同一个行为具有多个不同表现形式或形态的能力

条件：继承、重写、父类引用指向父类对象

优点：可替换、可扩充、够灵活、易简化

//创建父类，动物吃东西为抽象方法
abstract class animal {
     abstract void eat();
}
//子类继承父类，增加自己的方法
public class cat extends animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void work(){
        System.out.println("猫抓老鼠");
    }
}
//子类继承父类，增加自己的方法
public class dog extends animal{
    void eat(){
        System.out.println("狗吃骨头");
    }
    void work(){
        System.out.println("狗看家");
    }
}
//调用方法
public class test {
    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();//调用狗自己的方法
        }}
    public static void main(String[] args) {
        test.show(new cat());
        test.show(new dog());
    }
}

2 接口

2.1 默认方法与静态方法

public interface Used {
    public default void show1(){
        System.out.println("调用了接口中的默认方法A");
    };
    public static void show2(){
        System.out.println("调用了接口中的静态方法B");
    }
}
​
public class UseA implements Used{
    @Override
    public void show1() {
        System.out.println("实现了接口中的默认方法A");
    }
}
​
public class UseB implements Used{
​
}
​
public class Use implements Used{
    public static void main(String[] args) {
        UseA useA=new UseA();
        useA.show1();//通过实现调用接口中的默认方法
        Used.show2();//直接调用接口中的静态方法
    }
}

2.2 抽象方法的调用

//接口中的方法为抽象方法，没有方法体
public interface Tested {
    void showA();
    public abstract void showB();
}
​
//实现接口方法可以直接调用
public class TestA implements Tested{
    @Override
    public void showA() {
        System.out.println("省略的方法A");
    }
    
    @Override
    public void showB() {
        System.out.println("完整的方法B");
    }
}
​
//抽象类调用接口中的抽象方法需要子类继承（向上转型）才能使用
public abstract class TestB implements Tested{
}
​
public class TestC extends TestB{
    @Override
    public void showA() {
        System.out.println("省略的方法A");
    }
​
    @Override
    public void showB() {
        System.out.println("完整的方法B");
    }
}
​
public class Test {
    public static void main(String[] args) {
        TestA testA=new TestA();
        testA.showA();
        testA.showB();
        System.out.println("--------------");
        TestC testC=new TestC();
        testC.showA();
        testC.showB();
    }
}

3 内部类

3.1 成员内部类

public class Outer {
    private String name="成员内部类";
    //创建内部类与内部方法
    public class Inner{
        public void show(){
            System.out.println(name);
    }
}
    //在本类创建方法调用内部方法
    public void method(){
        Inner in=new Inner();
        in.show();
    }
}
    //主方法再调用本类中的方法
public class Test {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

3.2 局部内部类

public class Inner_3 {
    String name="成员内部类";
​
    public void method(){
        String nama="局部内部类";
        class inner{
            public void show(){
                System.out.println(name);
                System.out.println(nama);
            }
        }
        inner in=new inner();
        in.show();
    }
}
​
public class Inner_4 {
    public static void main(String[] args) {
        Inner_3 in3=new Inner_3();
        in3.method();
    }
}

3.3 匿名内部类

//通过接口
public interface impl {
    public void inner();
    public void outer(String name);
}
​
public class Inner{
    public void method(){
        impl i=new impl(){
​
            @Override
            public void inner() {
                System.out.println("匿名内部类，不带参数");
            }
​
            @Override
            public void outer(String name) {
                System.out.println("匿名内部类，带参数"+name);
            }
        };
        i.inner();
        i.outer("无名");
    }
}
​
public class Test {
    public static void main(String[] args) {
        Inner in=new Inner();
        in.method();
    }
}