一：封装

封装就是将类的状态信息隐藏在类的内部，不允许外部程序直接访问，通过该类提供的方法来实现对隐藏信息的操作和访问。

简而言之就是隐藏内部实现，提供对外方法。

访问修饰符

private：类中限定为private的成员，只能被这个类本身访问。如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。
default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
public：类中限定为public的成员，可以被所有的类访问。

this关键字

this关键字代表当前对象
this.属性调用当前属性
this.方法调用当前方法

java封装的实例

class Student{
    String name;
    private int age; //将age属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
    public void show(){
        System.out.println("名字: " + name);
        System.out.println("年龄: " + age);
    }
    public void getAge(int Age){
    this.age=age;
    }
}

class StudentDemo{
    public static void main(String[] args){
        Student s = new Student();
        s.show();
        System.out.println("-------------------");
        //给成员变量赋值
        s.name = "小李";
    //通过方法赋值
        s.getAge(19);
        s.show();

    }
}

二：继承

子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

Java语言的继承关系：是一种单继承的关系
一个子类只能有一个父类，而一个父类可以有多个子类
子类可以可以使用父类的属性和方法，但是父类不能够访问子类独有的属性和方法
创建子类对象时先执行父类的构造方法，然后在执行子类的构造方法
使用super关键字去调用父类的构造方法

Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。

final：
final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。

构造器：

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

java继承的例子

class Person1 {
    public String name="xiaoli";
    public int age=19;

}

class Student extends Person1 {
    void study() {//有一个study的方法，表示这个人可以学习
        System.out.println("I can study!");
    }
}

public class JiCheng {
    public static void main(String args[]) {
        Student stu = new Student();
        stu.study();
        //stu.name = "zhangsan";
        //stu.age = 20;
        System.out.println("姓名:" + stu.name + "\n" + "年龄:" + stu.age);
    }
}
//虽然student类中并没有声明这个studentde姓名和年龄，但是因为继承了person1，所以实例化后同样输出了年龄和姓名

I can study!
姓名：xiaoli
年龄：19

三：多态

对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。

接下来我们用代码来理解多态的自动转型和强制类型转型
满足条件：两者之间要存在继承或者是实现关系(接口）

class AllAnimal{
    public void speak(){
        System.out.println("我们都会动物");
    }
}



class Cat extends AllAnimal{
    public void speak(){
        System.out.println("我是猫")
    }
}




class Fish extends AllAnimal{
    public void speak(){
        System.out.println("我是鱼");
    }
    
    public void canDo(){
        System.out.println("我会游泳");
    }
}

这样就产生了父类引用指向子类对象，也就是自动向上转型。

public static void main(String[]args){
    AllAnimal a=new Cat();
    a.speak();      //我是猫

自动向上转型的实例：

AllAnimal a = new Fish();
a.speak();//我是鱼

分析一下： new Fish() 就是在堆内存中开辟了一个空间，但它是用AllAnimal 的引用 a 去当new Fish()的对象名的，即a指向子类Fish。编译的时候会首先去AllAnimal 类中找到speak（）方法，发现有这个方法，则编译通过。

但是：

AllAnimal a = new Fish();
a.canDo();   //报错

分析：canDo()方法是子类中增加的新方法，编译时先会去AllAnimal中找canDo()方法，但没有找到，所以编译不通过。

所以要引入向下转型来使父类的引用可以使用子类的新增方法。

AllAnimal a = new Fish();
a.speak();
//强制向下转型
Fish a1 = (Fish)a;
a1.canDo();

四：重载（Overloading）

方法重载是让类以统一的方式处理不同数据类型的手段。
一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时* * 通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

重写（Overriding）

子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
子类函数的访问修饰权限不能低于父类的。

五.instanceof关键字

if (a instanceof Cat) {

           System.out.println(true);

           // 类型的转换

       }else{

           System.out.println(false);

       }

用于判断：对象是否属于后面的类型，如果属于则返回true 如果不属于则返回false

龙宝.

发布了31 篇原创文章 · 获赞 1 · 访问量 1249

私信关注

java 面向对象的三大特性

一：封装

二：继承

三：多态

五.instanceof关键字

猜你喜欢