首页 > 编程语言 >7.Java面向对象

7.Java面向对象

时间：2024-04-26 21:36:18浏览次数：31  
标签：Java name void System 面向对象 println public out

Java面向对象

（物以类聚，分类的思维模式；适合处理复杂的问题）

什么是面向对象

  1. 面向对象编程（OOP）

  2. 本质：以类的方式组织代码，以对象的形式组织（封装）数据

  3. 抽象

  4. 三大特性：封装，继承，多态

值传递和引用传递

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);//1

        Demo04.change(a);

        System.out.println(a);//1
    }
    //返回值为空
    public static void change(int a)
    {
        a=10;

    }
}

//引用传递 对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        Demo05.change(person);
        System.out.println(person.name);//Bob
    }
    public static void change(Person person)
    {
        //person是一个对象：指向的 ----->Person person = new Person（）；
        //这是一个具体的人，可以改变属性
        person.name = "Bob";
    }

}
//定义了一个Person类，有一个属性，name
class Person{
    String name;
}

类与对象的关系

  1. 类是一种抽象的数据类型，它是对某一类事物整体描述，但是并不能代表某一具体的事物‘

  2. 对象是抽象概念的具体示例

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 xiaoming = new Student();
        Student xh = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 10;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xh.name = "小红";
        xh.age = 10;
        System.out.println(xh.name);
        System.out.println(xh.age);


    }
}

创建与初始化对象

构造器详细

package com.oop.Demo02;

public class Person {
    //一个类即使什么都不行，也会存在一个方法
    //显示的定义构造器
    String name;
    int age;
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    //2.构造器一般用来初始化值
    public Person() {
    }
    //有参构造:一旦定义了有参构造，无参构造必须显示定义
    public Person(String name) {
        this.name = name;
    }
    //alt + insert 自动生成构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
/*
 构造器：
      1.和类名相同
      2.没有返回值
 作用：
      1.new本质在调用构造器
      2.初始化对象的值
 注意点：定义有参构造后，如果想使用无参构造，显示的定义一个无参构造
 alt + Insert 可自动生成构造器
 */
/*
   public static void main(String[] args) {
        //new 关键词 实例化一个对象
        Person person = new Person("Bob");
        System.out.println(person.name);//Bob

    }
 */

上述小结

  public static void main(String[] args) {
        /*
        1. 类与对象
        类是一个模板：抽象，对象是一个具体的实例
        2. 方法
        定义，调用！
        3. 对应的引用
        引用类型： 基本类型（8）
        对象是通过引用来操作的：栈-->堆（地址）
        4. 属性：字段Filed 成员变量
        默认初始化：
        数字：0  0.0
        char：u0000
        boolean：false
        引用：null
        修饰符：属性类型 属性名 = 属性值！
        5. 对象的创建和使用
         - 必须使用new  关键字创造对象，构造器 Person Bob = new Person();
         - 对象的属性 Bob.name
         - 对象的方法 Bob.sleep()
        6. 类：
        静态的属性 属性
        动态的行为 方法

        ’封装，继承，多态‘
         */
    }

封装

高内聚 低耦合

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅暴露少量的方法给外部使用

属性私有 get/set

(封装 后续只粘贴属性 和 关键方法)

package com.oop.Demo04;
//类
public class Student {
    private String name;//名字
    private int id;//学号
    private char sex; //性别
    private int age;//年龄
    //提供一些可以操作这个属性的方法！
    //提供一些public 的get set方法
    //get 获得这个数据
    //set 给这个数据获得值
    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
    //alt+insert自动生成set，get

    public int getAge() {
        return age;
    }

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


public class Application {
    /*
    1. 提高程序的安全性，保护数据
    2. 隐藏代码的实现细节
    3. 统一接口
    4. 可维护性
     */
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("Bob");
        System.out.println(s1.getName());

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

继承

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

extends“扩展”，子类是父类的扩展

Java只有单继承没有多继承

ctrl + H 可看类层结构

package com.oop.Demo05;
//人
//在Java中，所有的类都直接或间接继承Object
public class Person {
    //public 公共的 private 私有的不可继承 default private
    private int money = 100_0000;
    public void say()
    {
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

//学生 is 人：子类（派生类）
//子类继承父类，就会拥有父类的全部方法！
public class Student extends Person{
    //ctrl + H 打开类的层次结果

}
//老师 is 人：子类（派生类）
public class Teacher extends Person{

}


public class Person {
    public Person() {
        System.out.println("Person无参构造执行");
    }

    protected String name = "Bob";
    public void print()
    {
        System.out.println("Person");
    }

}
public class Student extends Person{
    //ctrl + H 打开类的层次结果
    //super和this不同用
    public Student() {
        //隐藏代码，默认调用了父类的无参构造
        super();//调用父类的构造器，必须在子类构造器的第一行
        System.out.println("Student无参构造执行");
    }

    private String name = "wzj";
    public void test(String name)
    {
        //super调用父类的东西
        System.out.println(name);//QZ
        System.out.println(this.name);//wzj
        System.out.println(super.name);//Bob
    }
    public void print()
    {
        System.out.println("Student");
    }
    public void test1()
    {
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}

小结：

super注意点：

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

Vs this：

代表的对象不同：

​ this:本身调用者的对象

​ super：代表父类对象的应用

​ 前提：

​ this：没有继承也可以使用

​ super：只能在继承条件才能使用

​ 构造方法：

​ this();本类的构造

​ super()；父类的构造

重写

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

}
//继承
public class A extends B{
    @Override //注解：重写 有功能的注解！
    public void text() {
        System.out.println("A=>text");
    }
}
/*
public class Application {
    //静态方法和非静态方法有区别
    //静态方法：方法的调用只和左边定义的数据类型有关
    //非静态：重写
    public static void main(String[] args) {

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

重写小结：

重写：需要用继承关系，子类重写父类的方法

  1. 方法名必须相同
  2. 参数列表列表必须相同
  3. 修饰符：范围可以扩大 ：public>protected>default>private
  4. 抛出的异常：范围可以被缩小，但不能扩大 ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必须要一致：方法体不同！

为何需要重写？

  1. 父类的功能，子类不一定需要，或者不一定满足！
  2. Alt + Insert：override 重写快捷键

多态

多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 （类型转换异常！如不可String转换ClassCastException）
3. 存在的条件：继承关系，方法需要重写，父类的引用指向子类对象！ father f1 = new Son();
    1.static 方法，属于类 不属于示例不可重写
    2.final 常量；不可重写
    3.private 方法：私有 不可重写

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

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

}

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();//son子类重写了父类的方法，执行子类的方法
        s1.run();//son

        ((Student) s2).eat();//强制转成了Student类型
    }
}

instanceof （类型转换） 引用类型

作用：判断 是 什么类

1. 父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型：强制转换，丢失方法
4.方便方法的调用，减少重复的代码，简洁
抽象：封装，继承，多态！

public class Application {
    public static void main(String[] args) {
        //Object > Person > Student
         //System.out.println(X instanceof Y);能不能编译通过！
        Object object = new Student();
        System.out.println(object instanceof  Student);//true
        System.out.println(object instanceof  Person);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof Object);//true
        
    }
}

static 关键字

public class Person {
    //2.
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    //1.静态代码块只执行一次
    static{
        System.out.println("静态代码块");
    }
    //3.
    public Person()
    {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("*********************");
        Person person2 = new Person();

    }
}
静态代码块
匿名代码块
构造方法
*********************
匿名代码块
构造方法
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();
        s1.run();
        go();

    }
}

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Texy {
    public static void main(String[] args) {
        System.out.println(random());//随机数
        System.out.println(PI);
    }
}

抽象类

//abstract 抽象类：类 extends：单继承~ （接口可以多继承）
public abstract class Action {
    //约束~有人帮我们实现；
    //abstract ,抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
    //1. 不能new这个抽象类，只能靠子类去实现它：起到约束作用
    public void hello()
    {
        //2.抽象类可以写普通的方法
    }
    //3.抽象方法必须写在抽象类中~
    //抽象的抽象：约束~
}

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

抽象类又构造器嘛？有什么意义呢？

接口

（只有规范！自己无法写方法专业的约束约束和实现分离：面向接口编程~）

（接口的本质是契约）

作用：
    1.约束
    2.定义一些方法，让不同的人实现~
    3.方法 public abstract
    4.常量 public static final
    5.接口不能被实例化~，接口中没有构造函数
    6.implements可以实现多个接口
    7.必须要重写接口中的方法

public interface TimeService {
    void timer();
}

//抽象的思维~
//interface 定义的关键字， 接口都需要实现类
public interface UserService {
    //接口中的所有定义骑士都是抽象的public
    int age = 99;//常量~ public static final

    void add(String name);
    void del(String name);
    void update(String name);
    void query(String name);
}

import java.sql.Time;

//抽象类：extens~
//类可以实现接口implements接口
//实现了接口的类，就需要重写接口的方法~
//多继承~利用接口来实现多继承~
public class UserServicelmpl implements UserService, TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void del(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

内部类

在类的内部在定义一个类

public class Outer {
    private int id=10;
    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;

//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

这是内部类的方法
10

public class Outer {
    public void method()
    {
        //局部内部类
        class Inner
        {
            public void in()
            {
                
            }
        }

    }
}
//一个java类中又多个class类，但是只有一个public class方法
class A{

}


public class Text {
    public static void main(String[] args) {
        //没有名字初始化类
        //不用将实例保存到变量中~
        new Apple().eat();
        UserService userService = new UserService() {
            @Override
            public void hello() {

            }
        };
    }
}
class Apple{
    public void eat()
    {
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

标签：Java,name,void,System,面向对象,println,public,out
From： https://www.cnblogs.com/zuojiawang/p/18160905

相关文章

  • 哲学家就餐：死锁及解决方案 Java
    本文首发于公众号：腐烂的橘子哲学家就餐问题是计算机科学中的一个经典问题，1971年由荷兰计算机科学家艾兹格·迪科斯彻提出，五台计算机都试图访问五份共享的磁带时会产生问题，后来东尼·霍尔将其重新表述为哲学家就餐问题[1]。问题的详细描述可以参考链接。通俗来讲，就是有五个哲......
  • Java_web的复习之maven
    Apachemaven是一个项目管理和构建工具，它基于项目对象管理模型的概念，通过一小段描述信息来管理项目的构建2.作用:方便的依赖管理统一的项目结构标准的项目构建流程3.通过maven中的各种各样的插件，我们就可以完成对应的功能例如通过编译插件就可以对项目进行编译，通过测试插件......
  • 我刚开始学习java，我什么也不懂，框架到底是什么，没有框架可以使用java吗
    我刚开始学习java，我什么也不懂，框架到底是什么，没有框架可以使用java吗2024/4/1916:00:01当你刚开始学习Java时，"框架"可能是一个比较抽象的概念。简单来说，框架是一组预先编写好的代码结构和库，它们提供了一种组织和设计你的应用程序的方式。框架旨在简化开发过程，提高代码的可重用......
  • Java并发01---JMM模型、Volatile、CAS操作、自旋锁、ABA问题
    @目录JMM（JavaMemoryModel）Volatile修饰CAS（CompareAndSwap）ABA问题JMM（JavaMemoryModel）首先要明确的是JMM与JVM内存结构不是同一个概念，记的时候不要记混。我们先来回顾一下JVM内存结构，其包括了堆、方法区、虚拟机栈、程序计数器、本地方法区，其中前二者为线程共享，后三者为线程......
  • Java并发02---Synchronized的实现原理、锁的升级、锁的膨胀、对象头、锁的消除、偏向
    @目录何为synchronized前置知识：对象头锁的升级（锁的膨胀）偏向锁轻量级锁轻量级锁锁的消除何为synchronized我们知道，synchronized关键字能够将其修饰的代码块、方法、静态方法变成同步代码。我们在前文中已经介绍过了，使用volatile关键字修饰能保证变量在内存中的可见性，但不保证操作......
  • javascript高级编程系列 - 使用fetch发送http请求
    fetch采用模块化设计，api分散在多个对象上(Response对象，Request对象，Header对象),fetch通过数据流（stream对象）处理数据可以分块读取，有利于提高网站性能。发送GET请求fetch函数只传递一个url，默认以get方法发送请求。promisefetch(url).then(response=>response.json()).......
  • Java树形结构
    表结构createtablecommon_tree(idbigintnotnullcomment'主键'primarykey,p_idbigintnullcomment'父节点id',tree_codevarchar(100)nullcomment'树形区分',tree_describevarch......
  • java反汇编命令手册
    1.栈和局部变量操作1.1将常量压入栈的指令指令功能描述aconst_null将null对象引用压入栈iconst_m1将将int类型常量-1压入栈iconst_0将int类型常量0压入栈iconst_1将int类型常量1压入栈iconst_2将int类型常量2压入栈iconst_3将int类型常量3压入......
  • Java四种实现单例模式
    饿汉式/***1.饿汉式：线程安全，耗费资源*场景：*资源共享：当需要在多个模块中共享同一个实例时*全局访问点：作为全局唯一的访问点，例如日志记录器、配置管理器等。*线程安全要求高：饿汉式单例模式在类加载时就创建实例，因此不存在线程安全问题，适合多线程环境下使用。*避......
  • 从 Java 8 转换到 Java 11
    截至目前（2024年），十年前发布的Java8依然是Java中应用最广泛的版本，占比37%，其次是Java11。而目前的JDK最新版本为22，最新的LTS版本为JDK21。从Java8迁移到Java11可能意味着很大的工作量。潜在问题包括：删除的API、弃用的包、内部API的使用、对类加载程序的更......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99