Java面向对象编程，随堂笔记，仅供参考

最新推荐文章于 2022-03-01 22:08:38 发布

一个大萝北

最新推荐文章于 2022-03-01 22:08:38 发布

阅读量148

点赞数 1

分类专栏： java学习文章标签： java 多态抽象类封装

本文链接：https://blog.csdn.net/qq_40797578/article/details/114595623

版权

java学习专栏收录该内容

8 篇文章 1 订阅

订阅专栏

一、面向过程 & 面向对象

面向过程思想：
- 步骤清晰简单，第一步做什么，第二步做什么
- 面向过程适合处理一下较为简单的问题
- 线性思维
面向对象思想
- 物以类聚，分类的思维模式，将一个大问题分类为每个小问题，最后再对某个分类下的细节进行面向过程的思索。
- 适合处理复杂的问题，适合处理多人协作的问题
从宏观上我们使用面向对象的思想，再具体到微观操作，用面向过程的思路去处理

二、面向对象

面向对象编程—Object-Oriented Programming,OOP
本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：
- 封装
- 继承
- 多态

三、类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述、定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例

四、创建与初始化对象

使用new关键字创建对象

五、构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。有以下两个特点：

必须和类的名字相同
必须没有返回类型，也不能写void

idea生成构造器的快捷键alt+insert

无参构造器:

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    //无参构造器
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Person(){
        this.name = "xuqing";
    }
}

方法重载

有参构造器：

  //有参构造：一旦定义了有参构造，无参构造必须显示定义，就是留一个默认的空无参构造
    public Person(String name){
        this.name=name;
    }

六、封装

“高内聚、低耦合”：

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

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

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

属性私有，get/set

封装意义：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加

//学生类  private:私有
public class Student {
    //属性私有,不可以直接操作s1.name是错误的
    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 char getSex(){
        return  sex;
    }
    public void  setSex(char sex){
        this.sex=sex;
    }

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

Application.java:

        Student s1 = new Student();
        s1.setName("xq");
        System.out.println(s1.getName());
        s1.setAge(-1);//不合法，应该显示0
        System.out.println(s1.getAge());

七、继承（extends）

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

extends 子类是父类的扩展，子类又叫派生类

子类继承父类拥有父类的全部方法（public才可以继承，private是不可以继承的），只能单继承

ctrl+h：打开继承树

Object类

Father.java:

//在java中，所有的类，都默认直接或者间接继承object
public class Father {
    private int money = 1_0000;
    public void say(){
        System.out.println("说了一句");
    }

    public int getMoney() {
        return money;
    }

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

Son.java:

public class Son extends Father{

}

Application.java:

Son son = new Son();
        System.out.println(son.getMoney());
        son.say();

结果
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iJtJ2UY5-1615288108855)(C:\Users\samsung\AppData\Roaming\Typora\typora-user-images\image-20210305175552500.png)]$

八、重写（Override）

非静态方法：子类重写父类的方法（不能是static，只能是非静态方法才能重写）

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

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

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

为什么需要重写？父类的功能，子类不一定需要，或者不一定满足

Alt+insert

B.java:

//重写都是方法的重写，和属性无关
public class B {
    public  vor");
    }
}

A.java

public class A extends B {
    @Override//重写
    public void test() {
        System.out.println("A=>test");
    }
}

test.java:

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

九、多态

什么是多态？

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型是有很多

注意点：

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常提示：ClassCastExpection
存在条件：继承关系，方法需要重写，父类引用指向子类对象 father f1 = new son（）;以下不存在多态
static方法，属于类，不属于实例
final 常量
private 方法

//一个对象的实际类型是确定的
//new Student();
//new Persion();
//可以指向的引用类型就不确定了：父类的引用指向子类
//Student能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//persion 父类可以指向子类，但是不能调用子类独有的方法
Persion s2 = new Student();//通过父类new子类
Object s3 = new Student();

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

十、instanceof 类型转换

X instanceof Y

X是不是Y的子类型

父类引用指向子类的对象

把子类转换为父类，向上转型

把父类转换为子类，向下转型强制转换

方便方法的调用

十一、static

静态属性：静态变量使用类名直接调用，可以不用创建对象

静态代码块只执行一次，匿名方法块和构造方法每次被实例化一个新对象就被执行一次

final 断子绝孙

public class NoName {
    //2.赋初值
    {
  s\("匿名代码块");
    }
    //1.只执行一次
    static {
        System.out.println("静态代码块");
    }
    //3.
    public NoName(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        NoName noName1 = new NoName(.pintln("=============");
        NoName noName2 = new NoName();
    }
}

在这里插入图片描述

十二、抽象类（abstract）

只有方法名字，没有方法的具体实现

public abstract class A{
	public abstract void doSomething();
}

抽象类不能被new，只能靠子类去实现
抽象方法必须在抽象类中，抽象类中可以有普通方法
抽象的抽象：约束~

抽象类中是可以有构造函数的，尽管它不能被实例化，但是他被继承后，派生类可以实例化，而派生类在实例化调用构造函数时会先调用基类中的的构造函数，所以抽象类中的构造函数是可以被调用的，所以抽象类中可以有构造函数

存在的意义：将公有属性抽象出来，提高开发效率，提高程序的可扩展性。

十三、接口（interface）

只有规范，自己无法写方法，专业的约束，将约束和实现分离。

接口就是规范，定义是一组规则。

接口的本质是契约。

OO的精髓，是对对象的抽象

接口中默认所有定义其实都是抽象的 public abstract

继承接口关键词 implements ，重写接口中的方法

接口不能被实例化，接口中没有构造方法

接口类：UserService.java：

//interface 定义的关键字，接口都需要有实现类
public interface UserService {
    //接口定义就是常量 public static final
    int AGE = 99;
    //接口中的所有定义的方法其实都是抽象的
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

接口类 TimeService.java:

public interface TimeService {
    void timer();
}

接口实现类 UserServiceImpl.java

//抽象类 extends  接口类 implements
//类 可以实现接口 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 timer() {

    }
}

十四、内部类

内部类：在类中再创建一个类，如Inner类。可以获得外部类的私有属性
一个java类中可以有多个class类，但是只能有一个public class类

public class Outer {

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

    //一个java类中可以有多个class类，但是只能有一个public class类
    class A{}
}

Outer outer = new Outer();
        //通过外部类来实例化内部类
       // Outer.Inner inner = outer.new Inner();
        //inner.in();

匿名内部类:没有名字初始化类，不用将实例保存到变量中：

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

一个大萝北

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java面向对象编程，随堂笔记，仅供参考

一、面向过程 & 面向对象面向过程思想：步骤清晰简单，第一步做什么，第二步做什么面向过程适合处理一下较为简单的问题线性思维面向对象思想物以类聚，分类的思维模式，将一个大问题分类为每个小问题，最后再对某个分类下的细节进行面向过程的思索。适合处理复杂的问题，适合处理多人协作的问题从宏观上我们使用面向对象的思想，再具体到微观操作，用面向过程的思路去处理二、面向对象面向对象编程—Object-Oriented Programming,OOP本质就是：以类
复制链接

扫一扫