加油啊！

面向对象

创建对象、构造器

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

//学生类
public class Student {

    //属性：字段
    String name;
    int age;

    //方法
    public void study() {
        System.out.println(this.name + "在学习");
   }
}
/*
    public static void main(String[] args) {

        //类：抽象的，实例化
        //实例化后返回一个自己的对象
        //xiaoming对象就是一个Student类的具体实例

Student xiaoming = new Student();
    Student xiaodong = new Student();

        xiaoming.name = "小明";
                xiaoming.age = 13;

                System.out.println(xiaoming.name);
                System.out.println(xiaoming.age);

                xiaodong.name = "小冬";
                xiaodong.age = 18;

                System.out.println(xiaodong.name);
                System.out.println(xiaodong.age);
                }

 */

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点:
1.必须和类的名字相同
2.必须没有返回类型,也不能写void

构造器必须要掌握

使用new.关键字，本质是在调用构造器
用来初始化值
有参构造: 一旦定义了有参构造，无参就必须显示定义
快捷键：alt+ insert

package com.oop.demo02;

import javax.print.DocFlavor;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    int age;

    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    public Person() { }
    //有参构造：一旦定义了有参构造，无参就必须显示定义

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
   }
}
/*
    public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person("dongdong",13);

        System.out.println(person.name);
        System.out.println(person.age);
 */

简单小结类与对象

类与对象

类是一个模板:抽象，对象是一个具体的实例
方法

定义、调用!
对应的引用

引用类型:基本类型 (8大)

对象是通过引用来操作的:栈--->堆
属性:字段Field 成员变量

默认初始化:

数字: 0 0.0

char : u0000

boolean: false

引用: null

修饰符属性类型属性名 = 属性值
对象的创建和使用

-必须使用new 关键字创造对象，构造器例如：Person dongdong = new Person();

-对象的属性 dongdong.name

-对象的方法 dongdong.eat()
类

静态的属性属性

动态的行为方法

类里只有属性和方法

封装

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

封装(数据的隐藏)

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

记住这句话就够了: 属性私有, get/set

public class Student {

    //属性是私有的：private
    private String name;    //名字
    private int id; //学号
    private int age; //年龄

    //提供一些public的get、set方法
    //get 获取这个数据

    public String getName() {
        return this.name;
   }
    //set   给这个数据设置值

    public void setName(String name) {
        this.name = name;
   }
    //快捷键alt+ insert

    public int getId() {
        return id;
   }

    public void setId(int id) {
        this.id = id;
   }

    public int getAge() {
        return age;
   }

    public void setAge(int age) {
        if(age>100 || age<0){  //不正确的年龄
            this.age=18;
       }else {
            this.age = age;
       }

   }
}
/*
    public static void main(String[] args) {

        Student dongdong = new Student();

        dongdong.setName("冬冬");
        //设置名字为“冬冬”
        //dongdong.getName() 获取

        System.out.println(dongdong.getName());

        dongdong.setAge(120);//不正确的年龄
        System.out.println(dongdong.getAge());
    }
    // 1.提高程序的安全性，保护数据
    // 2.隐藏代码的实现细节
    // 3.统一接口
    // 4.系统可维护性增加了

 */

继承

子类 extends 父类

继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。
extends的意思是”扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
子类和父类之间,从意义.上讲应该具有"is a"的关系.
object类
super
方法重写

修饰符优先级

//public

//protected

//default

//private 私有的无法被继承
快捷键 Ctrl+H 查看继承树
- 在Java中，所有的类，都默认直接或者间接继承Object

super

注意点：

super调用父类的构造方法，必须在构造方法的第一一个
super必须只能出现在子类的方法或者构造方法中!
super和this 不能同时调用构造方法!

this注意点：

this:调用本类的对象
super:调用父类对象的应用

前提
this:没有继承也可以使用
super:只能在继承条件才可以使用

构造方法

this() 本类的构造

super()父类的构造

方法的重写

重写:需要有继承关系，子类重写父类的方法!
1. 方法名必须相同
2. 参数列表列表必须相同
3. 修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
4. 抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致; 方法体不同!
为什么需要重写:

父类的功能，子类不一-定需要，或者不一定满足!

快捷键一样是Alt + Insert ; override;

自学Java笔记 Day07

面向对象

创建对象、构造器

简单小结类与对象

封装

继承

super

方法的重写

猜你喜欢