加油啊！

面向对象

创建对象、构造器

• 使用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

• 构造器必须要掌握

  1. 使用new.关键字，本质是在调用构造器

  2. 用来初始化值

  3. 有参构造: 一旦定义了有参构造，无参就必须显示定义

  4. 快捷键：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);
   */
  ​

简单小结类与对象

1. 类与对象

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

2. 方法

   定义、调用!

3. 对应的引用

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

   对象是通过引用来操作的:栈--->堆

4. 属性:字段Field 成员变量

   默认初始化:

   数字: 0 0.0

   char : u0000

   boolean: false

   引用: null

   修饰符 属性类型 属性名 = 属性值

5. 对象的创建和使用

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

   -对象的属性 dongdong.name

   -对象的方法 dongdong.eat()

6. 类

   静态的属性 属性

   动态的行为 方法

   类里只有属性和方法

封装

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

• 封装(数据的隐藏)

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

  记住这句话就够了: 属性私有, 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

   

  注意点：

  1. super调用父类的构造方法，必须在构造方法的第一一个

  2. super必须只能出现在子类的方法或者构造方法中!

  3. super和this 不能同时调用构造方法!

  this注意点：

  1. this:调用本类的对象

  2. super:调用父类对象的应用

     前提

  3. this:没有继承也可以使用

  4. super:只能在继承条件才可以使用

  构造方法

  this() 本类的构造

  super()父类的构造

方法的重写

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

  1. 方法名必须相同

  2. 参数列表列表必须相同

  3. 修饰符:范围可以扩大但不能缩小:public>Protected>Default>private

  4. 抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)

• 重写，子类的方法和父类必要一致; 方法体不同!

• 为什么需要重写:

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

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

标签：dongdong,Java,name,age,Day07,new,自学,父类,public
来源： https://www.cnblogs.com/jgcs775/p/12555893.html