温故而知新：重温Java第三天

Java学习第三天

面对对象

什么是面对对象

  • Java的核心思想是OOP

  • 面向过程思想：

    • 步骤清晰简单，第一步做什么，第二步做什么

    • 面对对象适合处理一些较为简单的问题

  • 面对对象思想：

    • 分类的思维方式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面对过程的思索。

    • 面对对象适合处理复杂的问题，适合处理需要多人处理的问题。

  • 面对对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。

  • 面对对象的三大特性

    1. 封装：封装是把客观事物抽象成类，并且把自己的属性和方法让可信的类或对象操作，对不可性的隐藏。

    2. 继承：继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

    3. 多态：允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。这就意味着虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

类和对象的创建

  • 对象是具体的事物，类是抽象的

  • 创建对象：使用new来创建对象

public class Main {
    public static void main(String[] args) {
        //类，抽象的，需要实例化；
        //类实例化后会返回一个自己的对象；
        Student student = new Student();
        //赋值给student对象里面的name属性为小明
        student.name = "小明";
//        调用方法
        student.study();
    }
}
//再定义一个类
class Student{
    String name;
    int age;
    public void study( ) {
        System.out.println(this.name+"在学习");
    }
    
}

image-20210616203005736

  • 无参构造和有参构造

public class Main {
    public static void main(String[] args) {
        //类，抽象的，需要实例化；
        //类实例化后会返回一个自己的对象；
        Student student = new Student();
        student.name = "小明";
        System.out.println(student.name);
        //创建有参构造函数
        Student student1 = new Student("666");
        System.out.println(student1.name);
    }
}
//再定义一个类
class Student{
    String name;
//        有参构造
    public Student(String name) {
        this.name=name;
    }
    //    无参构造
    public  Student( ) {
    }
}

创建对象内存分析

public class Main {
​
    public static void main(String[] args) {
        //实例化类
        Pet dog = new Pet();
       String name =dog.name="旺财";
       int age =  dog.age=16;
        System.out.println(name);
        dog.shout();
    }
}
class Pet{
    public  String name;
    public  int age;
    //无参构造
    public void shout() {
        System.out.println("叫了一声");
    }
}

  • 上图所示，具有两个类，Main类以及Pet类

  • Main类中有main()方法，Pet类中有个shot()方法以及name，age两个属性。

image-20210616211743030

  • 上图所示，当创建对象时，堆中将会生成相对应的属性。

封装

  • 我们程序设计要追求"高内聚，低耦合"。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合：仅暴露少量的方法给外部使用。

  • 封装(数据的隐藏)

    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

  • 属性私有(private)，GET//SET.

public class 封装 {
​
    public static void main(String[] args) {
        Student1 student1 = new Student1();
//        student1.name="";//无法直接调用私有权限的属性，会报错。
​
        student1.setName("旺财");//但是可以使用公开的方法来调用他的私有属性。
        System.out.println(student1.getName());
    }
}
class Student1{
    //私有
    private String name;
    private int id;
    private  int age;
​
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}

继承

什么是继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

  • extands 的意思是扩展，子类继承父类。

  • java中只有单继承，没有多继承。

  • 子类用于父类的全部方法

  • 在Java中所有的类都会直接或者间接继承Object

public class Main  {
    public static void main(String[] args) {
        //创建子类的对象
        Student student = new Student();
        student.say();//由此可见，方法并没有写再Student类中，而是写在父类中，但是子类却有这个方法。
    }
}
//父类
    class Father{
    public void say(){
        System.out.println("我是帅哥");
    }
}
//子类
class Student extends Father{
}

super

public class Main  {
    public static void main(String[] args) {
        //创建子类的对象
        Student student = new Student();
        //实验1输出
        student.say("1");
        //实验2输出
        student.say2();
​
    }
}
//父类
    class Father{
    protected String name = "zhb";
​
    public void print(){
        System.out.println("父类的print");
    }
    }
​
//子类
class Student extends Father{
​
    private  String name = "942";
​
    //实验1
    public void say( String name){
        System.out.println(name);//这里输出的是传入的参数name
        System.out.println(this.name);//这里输出的是自身类定义的name：942
        System.out.println(super.name);//这里是父类定义的name：zhb
    }
    //实验2
    public void say2(){
       print();//自身的方法
       this.print();//指向自身的指向
       super.print();//super:继承父类的方法
    }
    public void print(){
        System.out.println("子类的print");
    }
}

  • 在实验中，有两个例子，第一个我们在子类，父类分别定义了属性name并且赋值以及在主方法中还会传入一个实参name，并且编写方法say()分别输出。

    image-20210616223405439

  • 实验2中我们在父类中定义方法print()输出的是"父类的print"，子类中定义相同方法名的方法print()输出的是"子类的print"，编写方法say2()输出，可以得到。

image-20210616223531448

  • 由此可见，super就是调用父类的构造方法，this是本身调用这这个对象。

  • super 只能出现在子类的方法或构造方法中。

  • super和this不能同时调用构造方法

方法重写

  • 需要有继承关系，子类重写父类的方法

  • 方法名必须相同，方法体不同

  • 参数列表必须相同

  • 修饰符：范围可以扩大，不可以缩小

    • public-->protected-->Default-->private-->

  • 抛出的异常：范围可以缩小不可以扩大，

    • ClassNotFoundException -->Exception(大)

  • 为什么需要重写

    • 父亲的功能，子类不一定需要或者不一定满足。

public class 方法重写   {
​
    public static void main(String[] args) {
​
        A a = new A();
        B b = new A();//因为A继承了B所以可以创建A；
        a.text();
        b.text();
    }
}
class A extends B{
    @Override
    public void text() {
        System.out.println("A-->text()");
    }
}
class B{
    public void text(){
        System.out.println("B-->text()");
    }
}

image-20210616230046662

  • 可以看到上方输出B类的text时候变成了子类中的输出，这就是方法重写，重写父类中具有相同方法名的方法。

 

多态

什么是多态

  • 即一个方法可以根据发送对象的不同而采用多种的行为方式

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

  • 多态存在的条件

    • 有继承关系

    • 子类重写父类的方法

    • 父类应用指向子类对象

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

instanceof和类型转换

  • 类型转换

    • 父类引用指向子类的对象

    • 把子类转换父类，向上转型。

    • 把父类转换成子类，向下转型，需要强制转换。

    • 方便方法的调用，减少重复的代码。

posted on 2021-06-16 23:12  阿滨滨  阅读(55)  评论(0)    收藏  举报
博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3