自学Java笔记 Day07

加油啊!

面向对象

创建对象、构造器

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

上一篇:Java API:day07 【 ArrayList】


下一篇:spring 使用说明(转)