java三大特性

封装、继承、多态

封装

关键词：private

该露的露，该藏的藏。

高内聚，低耦合

高内聚：类内部的数据操作细节自己完成，不允许外部干预；

低耦合: 仅暴露少量方法给外部使用。

封装(数据的隐藏)：应该禁止直接访问一个对象中数据的实际表示，通过操作接口来访问

重点！！！属性私有，get/set。

private。

package charpter5.Demo05;

public class Application {

    public static void main(String[] args) {
        Student student = new Student();
        //不能用student.name直接操作了，因为属性私有。
        //需要用一些public的get()/set()方法。
        System.out.println(student.getName());
        student.setName("ssl");
        System.out.println(student.getName());

    }
}

package charpter5.Demo05;

//类
public class Student {
    //封装 属性私有，数据隐藏
    //名字
    private String name;
    //学号
    private int id;
    //性别
    private char sex;

    public String getName(){
        return this.name;
    }

    public void setName(String name){
        this.name=name;
    }
    //alt+insert快捷键，可以直接添加get()/set()方法
    //初始化的时候可以加相关的约束。
    public int getId() {
        return id;
    }
}

继承

关键词：extends super public protected default private

子类、派生类：是父类(基类)的拓展。

object类：所有类的父类。

package charpter5.Demo06;

//在java中，所有的类，都默认直接或者间接继承Object类。
//java中只有单继承，没有多继承。

//父类
public class Person {
    /**四个修饰符
     *     //public  公有变量：类内部、同一个包、子类、任何地方
     *     //protected 保护变量：类内部、同一个包、子类
     *     //default  默认变量：类内部、同一个包
     *     //private  私有变量：类内部 用来封装，一般用在属性上，会开放一些get/set方法来操作属性
     */
    //快捷键 ctrl+H 打开继承树

    //公有实例变量
    public int money =10_000_00;


    public void say(){
        System.out.println("hello,I am a person");
    }
}

package charpter5.Demo06;

//子类 继承父类 就会拥有父类的全部方法。
public class Student extends Person{

}

package charpter5.Demo06;

//子类
public class Teacher extends Person{

}

package charpter5.Demo06;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();  //输出：hello,I am a person
    }
}

super关键词: 访问父类的属性和方法 super. 私有的不能访问。

创建对象的时候，先调用父类的构造器，再调用子类的构造器。子类的构造器内默认第一行有super()（父类的无参构造器）。

注意点：

super调用父类的构造方法，必须在构造方法的第一个。
super必须只能出现在子类的方法或者构造方法中。
super和this 不能同时调用构造方法！因为都要求在第一行。

super VS this：

代表的对象不同：

this：本身调用者这个对象

super：父类对象的应用

前提：

this：没有继承也可以使用

super：只能在继承条件才可以使用

构造方法：

this：本类的构造

super：父类的构造

package charpter5.Demo06;

//父类
public class Person {

    protected String name = "ssl_Person";

    public void print(){
        System.out.println("Person");
    }

    public Person(){
        System.out.println("Person构造");
    }

}

package charpter5.Demo06;

//子类 继承父类 就会拥有父类的全部方法。
public class Student extends Person{

    private String name = "ssl_Student";

    //super 用来访问父类的属性和方法
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
        /**
         * ssl_Application
         * ssl_Student
         * ssl_Person
         */
    }

    public void print(){
        System.out.println("Student");
    }

    public void test(){
        print();          //相当于用this.
        this.print();
        super.print();
        /**
         * Student
         * Student
         * Person
         */
    }

    public Student(){
        System.out.println("Student构造");
    }

}

package charpter5.Demo06;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        /**
         * Person构造
         * Student构造
         */
        student.test("ssl_Application");
        student.test();
    }
}

方法重写 -----重写的都是非静态方法，与属性无关。关键词不能为private 需要有继承关系

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大；但不能缩小。
抛出的异常：范围可以缩小，但不能扩大。

package charpter5.Demo07;

//父类
public class B {
    public static void test(){
        System.out.println("B_static");
    }

    public void test2(){
        System.out.println("B");
    }
}

package charpter5.Demo07;

//子类
public class A extends B{
    public static void test(){
        System.out.println("A_static");
    }

    public void test2(){
        System.out.println("A");
    }
}

package charpter5.Demo07;

//重写都是非静态方法 与属性无关
public class App {
    public static void main(String[] args) {
        A a = new A();
        a.test();    //输出：A_static

        //方法的调用只和左边的类型有关。
        //父类的引用指向了A
        B b = new A();
        b.test();    //输出：B_static

        B c = new B();
        a.test2();  //输出：A
        b.test2();  //输出：A   方法重写
        c.test2();  //输出：B

        /**
         * 静态方法和非静态方法有区别。
         */
    }
}

多态

动态编译：类型，可扩展性

同一方法可以根据发送对象的不同而采取多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

多态存在的条件：

有继承关系。
子类重写父类方法。
父类指向子类对象。

注意：多态是方法的多态，属性没有多态。

package charpter5.Demo08;

public class Person {

    public void run(){
        System.out.println("Person_run");
    }

}

package charpter5.Demo08;

public class Student extends Person{
    public void run(){
        System.out.println("Student_run");
    }

    public void eat(){
        System.out.println("eat");
    }

}

package charpter5.Demo08;

public class App {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        Student s1 = new Student();
        //父类的引用指向子类的类型
        Person s2 = new Student();
        //只能调用父类有的方法，子类重写，调用子类，未重写，调用父类。
        Object s3 = new Student();

        s2.run();

        //s2.eat();  报错，父类没有该方法
        //强制类型转换，可以访问。
        ((Student)s2).eat();   //输出：eat

        /**
         * 多态是方法的多态，属性没有多态
         * 父类和子类才行，类型转换异常ClassCastException
         * 存在条件：继承关系、有方法重写、父类引用指向子类对象。
         *
         * 1.final不能重写
         * 2.private不能重写
         * 3.static不能重写
         */

    }
}

instanceof与类型转换

关键词：instanceof 引用类型转换

package charpter5.Demo08;

public class App {
    public static void main(String[] args) {

        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        System.out.println(s3 instanceof Person);
        System.out.println(s3 instanceof Student);
        /**
         * true
         * true
         * 判断类型是否相关，父子关系在一条线上为true 否则为false
         * 同级编译报错。
         */

        //类型转换
        /**
         * 父类为高，子类为低
         * 高转低用强制转换   向下转型   丢失部分方法
         * 低转高可以默认    向上转型
         * 方便方法的调用。
         */
        ((Student)s2).eat();
    }
}

posted @ 2022-09-27 12:04 林每天都要努力阅读(45) 评论(0) 收藏举报

刷新页面返回顶部

ssl-study

java三大特性

java三大特性

封装

继承

多态

公告