【day08~10】Java面向对象基础认识

面向对象

  • 面向对象编程的本质就是:以类的方式组织代码,以对象的形式封装数据

1.类与对象的关系

  • 类是一种抽象的数据类型,它是对某一类事务整体描述/定义,但是并不能代表某一个具体的事物
    • Person类、Pet类、Car类等,这些类都是用来描述/定义某一类具体事物应该具备的特点和行为
  • 对象是抽象概念的具体实例
    • 张三就是一个人的具体实例,张三家里的来福就是狗的一个具体实例。
    • 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念。

2.创建与初始化对象

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

类的创建:

package com.oop.demo02;

//学生类
public class Student {
    //属性:字段
    String name;//null
    int age;//0

    //方法
    public void study(){
        System.out.println(this.name+"学生在学习");
    }
}

对象的创建:

package com.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类:抽象的,需要实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student student = new Student();
        Student xiaohong = new Student();
        Student abin = new Student();

        abin.name="阿宾";
        abin.age=16;

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

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

示例:类及构造器

package com.oop.demo02;

//Java------>class      Ctrl+Alt+Shift+s打开项目结构 即可添加out文件夹下的class文件
public class Person {
    //一个类即使什么都不写,它也会存在一个方法(构造方法)
    //显示的定义构造器

    String name;
    int age;

    //实例化初始值
    //1.使用new关键字,本质是在调用构造器
    //2.用来初始化值
    public Person() {//无参构造器
        //this.name="卡兹克";
    }


    //有参构造:一旦定义了有参构造,无参就必须显示定义,否则就无效
        //会根据给予的参数匹配(方法重载)

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //alt+insert会快捷生成构造器
}
/*
public static void main(String[] args) {
        //new 实例化了一个对象
        Person person = new Person("卡兹克",4);
        System.out.println(person.name);//卡兹克
    }

    构造器:
        1.必须和类的名字相同
        2.必须没有返回类型,也不能写void
      作用:
        1.new本质是在调用构造方法
        2.初始化对象的值
     注意点:
        1.定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造

        //Alt+Insert
 */

示例:对象

package com.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //new 实例化了一个对象
        Person person = new Person("卡兹克");
        System.out.println(person.name);//卡兹克
    }
}

输出图

在这里插入图片描述

小结类与对象
  1. 类与对象
    • 类是一个模板:抽象 的,对象是一个具体实例
  2. 方法
    • 定义、调用
  3. 对象的引用
    • 引用类型:基本类型(8)
    • 对象是通过引用来操作的:栈---->堆
  4. 属性:字段Filed 成员变量
    • 默认初始化:
      • 数字:0 0.0
      • char: u0000
      • boolean:false
      • 引用:null
    • 修饰符 属性类型 属性名= 属性值
  5. 对象的创建和使用
    1. 必须使用new 关键字创造对象,还需要构造器 Person link= new Person();
    2. 对象的属性 link.name()
    3. 对象的方法 link.sleep()
    • 静态的属性 属性
    • 动态的行为 方法

3.封装

  • 该露的露,该藏的藏
    • 我们程序设计要追求”高内聚,低耦合“。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用
  • 封装(数据的隐藏)
    • 通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏
    • 属性私有 get/set

示例:类 私有数据/属性设置公共接口

package com.oop.demo04;

    //类     privates私有
public class Student {
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄

    //提供一些可以操作这个属性的方法
    //提供一些public的get,set方法

    //get 获得这个数据/属性
    public String getName(){
        return this.name;
    }

    //set 给这个数据/属性设置值
    public void setName(String name){
        this.name=name;
    }

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

        public char getSex() {
            return sex;
        }
        public void setSex(char sex) {
            this.sex = sex;
        }

        public int getAge() {
            return age;
        }
        public void setAge(int age) {
        if (age>150 || age<0){
            this.age=3;
        }else {
            this.age = age;
            }
        }
    }

示例:对象 使用

package com.oop;

import com.oop.demo04.Student;

/*
1.提高程序的安全性,保护数据
2.隐藏代码的程序细节
3.统一接口
4.提高系统的可维护性
 */

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("潘森");

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


        s1.setAge(999);//不合法的
        System.out.println(s1.getAge());
    }
}

输出图

在这里插入图片描述

4.继承

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

  • extends的意思是“扩展”。子类是父类的扩展

  • Java中类只有单继承,没有多继承(一父多子,一子一父)

  • 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

  • 继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示

  • 子类和父类之间,从意义上讲应该具有“is a”的关系

    示例:父类

    package com.oop.demo05;
    
    //在Java中,所有的类都默认直接或间接继承Object
    
    //Person 人: 父类
    
    public class Person /* extends Object */{
    
        //public
        //private
        //default
        //protected
    
        private int money=10_0000_0000;
    
        public void say(){
            System.out.println("说了一句话");
        }
    
        public int getMoney() {
            return money;
        }
        public void setMoney(int money) {
            this.money = money;
        }
    }
    

    示例:子类

    package com.oop.demo05;
    
    //学生 is 人:派生类(子类)
    //子类继承了父类。就会拥有父类的全部方法
    public class Student extends Person{
        //Ctrl+H 打开族谱
    }
    

    示例:对象应用

    package com.oop;
    
    
    import com.oop.demo05.Student;
    
    public class Application {
        public static void main(String[] args) {
            Student student = new Student();
            student.say();
            System.out.println(student.getMoney());
        }
    }
    

    输出图

    在这里插入图片描述

  • object类

  • super this

    • super注意点

      • 1.super调用父类的构造方法,必须在构造方法的第一
      • 2.super必须只能出现在子类的方法或者构造方法中
      • 3.super和this不能同时调用构造方法
    • this注意点:

      • 代表对象的不同:

        this:本身调用者这个对象

        super:代表父类对象的应用

      • 前提

        this:没有继承也可以使用

        super:只能在继承条件下才能使用

      • 构造方法

        this();本类的构造

        super();父类的构造

    示例:父类

package com.oop.demo05;

//在Java中,所有的类都默认直接或间接继承Object

//Person 人: 父类
public class Person /* extends Object */{

    public Person() {
        System.out.println("拉亚斯特无参执行了");
    }

    protected String name="亚托克斯";

    public void print(){
        System.out.println("拉亚斯特");
    }
}

实例:子类

package com.oop.demo05;

//学生 is 人:派生类(子类)
//子类继承了父类。就会拥有父类的全部方法
public class Student extends Person{
    public Student() {
        //隐藏代码:调用了父类的无参构造
        //super();  调用父类的构造器的代码,必须要在子类构造器内代码的第一行
        System.out.println("凯隐无参构造执行了");
    }

    private String name="剑魔";

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

    public void test1(){
        print();
        this.print();
        super.print();
    }

   public void test2(String name){
       System.out.println(name);
       System.out.println(this.name);
       System.out.println(super.name);
   }
}

示例:应用

package com.oop;

import com.oop.demo05.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test2("暗裔");
        student.test1();
    }
}

输出图

在这里插入图片描述

方法的重写

重写:需要有继承关系,子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符:
范围可以扩大但不能缩小:Public>Protected>Default>Private
4.抛出的异常:
范围可以被缩小,但不能扩大:ClassNotFoundException–>Exception(大)

重写,子类的方法和父类必须要一致;方法体不同

为什么需要重写:
1.父类的功能,子类不一定需要,或者不一定满足
Alt+Insert:override;

示例:父类

package com.oop.demo05;

//重写都是方法的重写与属性无关
public class B {
    public  void test(){
        System.out.println("B-test");
    }
}

示例:子类

package com.oop.demo05;

//继承关系
public class A extends B{
    @Override
    public void test() {
        System.out.println("A-test");
    }
}

示例:应用

package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;

public class Application {

    //静态方法和非静态方法的区别很大
    //静态方法:方法的调用只和左边定义的数据类型有关

    //非静态:重写

    public static void main(String[] args) {
        //方法的调用只和左边定义的数据类型有关
        A a=new A();
        a.test();//A

        //父类的引用指向了子类
        B b=new A();//子类重写了父类的方法
        b.test();//B
    }
}

输出图

在这里插入图片描述

5.多态

  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
  • 一个对象的实际类型是确定的,但可以指向对象的引用类型有很多
  • 多态存在的条件
    • 有继承关系
    • 子类重写父类方法(方法需要重写)
    • 父类应用指向子类对象
  • 注意:
      1. 多态是方法的多态,属性没有多态性
      2. 父类和子类,有联系 类型转换异常 ClassCastException

示例:父类

package com.oop.demo06;

public class Person {
    public void run(){
        System.out.println("润了");
    }
}

示例:子类

package com.oop.demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("神神");
    }
    public void eat(){
        System.out.println("吃");
    }
}

示例:应用

package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {

    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定:父类的引用指向子类
        //Student 能调用的方法都是自己的或继承父类的
        Student s1 = new Student();
        //Person    父类型,可以指向子类,但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3=new Student();

        //对象能执行哪些方法,主要看对象左边的类型,和右边关系不大
        s2.run();//子类重写了父类的方法,执行子类的方法
        s1.run();
    }
}

输出图

在这里插入图片描述

instance of

6.static关键字

​ 和类一起加载

示例:

package com.oop.demo07;

public class Student {
    private static int age;//静态的变量
    private double score;//非静态的变量

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.score);
        System.out.println(Student.age);

        new Student().run();
        Student.go();

    }
}

7.抽象类

  • abstract修饰符可以用来修饰方法也可以用来修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是修饰类
  • 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类
  • 抽象类:不能使用new关键字来创建对象,它是用来让子类继承的
  • 抽象方法:只有方法的声明,没有方法的实现,他是用来让子类实现的
  • 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类

8.接口

  • 普通类:只有具体实现
  • 抽象类:具体实现和规范(抽象方法)都有
  • 接口:只有规范
  • 接口就是规范,定义的是一组规则,体现了现实世界中“如果你是…则必须能…”的思想。如果你是飞机,则必须能飞。如果你是汽车,则必须能跑。如果你是直升机,则必须能闪电旋风劈。
  • 接口的本质是契约,就像物理规则。大家都遵守
  • 接口的作用:
      1. 约束
      1. 定义一些方法,让不同的人实现
      1. 接口中默认的方法都是public abstract
      1. 接口定义的属性都是常量 public static final
      1. 接口不能被实例化(抽象类也一样不能被实例化);因为接口中没有构造方法
      1. implements可以实现多个接口
      1. 必须要重写接口中的方法

示例:接口1

package com.oop.demo09;

//interface 定义的关键字,接口都需要实现类
public interface UserService {

    //接口定义的属性都是常量   public static final
      int age=99;

    //接口中的所有定义的方法其实都是抽象的 默认自带public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

示例:接口2

package com.oop.demo09;

public interface TimeService {
    void time();
}

示例:接口的实现类

package com.oop.demo09;

//抽象类:extends-单继承
//一个类可以通过implements实现接口
//实现了接口的类,需要重写接口中的方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }
    @Override
    public void delete(String name) {

    }
    @Override
    public void update(String name) {

    }
    @Override
    public void query(String name) {
        
    }
    @Override
    public void time() {
        
    }
    
}

9.内部类(扩展)

  • 内部类就是在一个类的内部再定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就称为外部类
    1. 成员内部类
    1. 静态内部类:用static作修饰词
    1. 局部内部类:public class内一个方法中再创建一个class类
    1. 匿名内部类:没有名字初始化类,不用将实例保存到变量中

示例:内部类

package com.oop.demo10;

public class Outer {
    private int id=10086;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){

            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

示例:应用

import com.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        //外部类通过new关键词实现
        Outer outer = new Outer();
        outer.out();
        //内部类通过外部类来实例化
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

输出图

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值