java面向对象笔记

最新推荐文章于 2024-07-17 01:27:07 发布

信小呆666

最新推荐文章于 2024-07-17 01:27:07 发布

阅读量499

点赞数

分类专栏： java系统学习文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_44480609/article/details/125211976

版权

java系统学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1.OOP详解

面向对象的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
抽象：就是抽出具象化的东西
三大特点：封装，继承，多态。

1.1 class类

我们面向对象，就是把一个一个抽象的事务具象化一个类，然后把属性和行为定义出来。

定义类

public class Cat {
    String name;
    int age;
    
    void eat(){
        System.out.println("小猫吃鱼！");
    }
}

这就是一个类，小猫的名字和年龄是它本身的属性，吃是小猫的行为

1.2类与对象的关系

类是一种抽象的数据类型，而对象是对这种抽象的类的实例化。

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();

    }

2.类详解

2.1 this关键字

this翻译出来就是这个，每一个类都有一个this，他是一个引用。通常情况下可以省略。
在实例方法中，或者构造方法中，为了区分局部变量和实例变量，不能省略。

 private String name;
 public void setName(String name) {
        this.name = name;
    }

这个时候区分这个this.name代表类种属性的name而不是局部变量。

2.2 构造方法

每个类都有一个默认的构造方法，和类名一样的无参构造。
但是如果我们写了一个构造器，系统就不会自动生成无参构造器了

public class Cat {
    private String name;
    int age;
    public Cat() {
      
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void eat(){
        System.out.println("小猫吃鱼！");
    }


}

alt+insert可以选择constrouctor快速的生成构造方法。构造方法可以重载。

3.封装 private

一个类的属性不应该完全暴露，不然就会被随意更改，我们需要定义一个方法，通过方法来操作我们的属性，这就是封装的基本理念。
在这里插入图片描述

3.1 封装的意义

private 是私有的意思，我们把属性通过private修饰，然后通过方法去取值和赋值，这样对于一些违规的操作我们就可以在方法里进行过滤，比如年龄如果传过来超过一百五十岁这种。

public class Cat {
    private String name;
    private int age;
    public Cat() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void eat(){
        System.out.println("小猫吃鱼！");
    }


}

alt+inser也可以快速生成

提高程序的安全性，保护数据。

隐藏代码的实现细节
统一用户的调用接口
提高系统的可维护性
便于调用者调用。

4.继承 extends

类与类直接可以继承，比如我们定义一个人类，然后男人类和女人类就可以继承人类。完全继承他的属性和方法。还有自己的特定的属性。

public class Person {
    private String name;
    private int age;

    public void eat() {
        System.out.println("吃");
    }
}

public class Man extends Person {
    private String huzi;
    
    public void niao(){
        System.out.println("站着尿尿");
    }
}

我们就定义是一个人类，基本上每个人都是有年龄名字和吃的行为，但是男人除了人类的特性，还有胡子和站着尿尿的行为，这样我们为了不重复声明属性和行为，直接继承即可。

一个类只能单继承，只能继承一个父类，但是一个父类可以有多个子类。
Object类是所有类的父类。

4.1 Super关键字

之前介绍了this关键字，是类的引用，Super关键字就是代表父类的引用。

  public void niao(){
        super.eat();
        System.out.println("站着尿尿");
    }

我们子类在尿尿的时候，可以调用父类吃的方法，吃完在尿。

不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和
super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

4.2方法重写

之前介绍了方法的重载，是方法名相同参数类型数目和返回值不同。
方法重写是发生在子类中，参数和方法名返回值类型都得相同。

public class Man extends Person {
    private String huzi;

    public void niao(){
        super.eat();
        System.out.println("站着尿尿");
    }

    @Override
    public void eat() {
        super.eat();
    }
}

这里也可以用alt+insert快速重写父类方法，当然super还是调用父类的，我们可以删掉自己重写自己的方法。

静态方法不能重写
私有方法不能被子类重写

5.多态

父类引用指向子类对象，就是多态
编译看左边，运行看右边。

 public static void main(String[] args) {
        Person person = new Man();
        person.eat();
    }

这边运行结果是运行的Man中重写的eat方法。

多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

 public static void main(String[] args) {
        Mod("多态的一个使用场景");
    }

    public static void Mod(Object object){
        System.out.println(object.toString());
    }

这种就是利用多态的特性，编译看左边，利用父类的特性通过编译，运行的时候是实际安装子类的方法去实现的。

  public static void main(String[] args) {
        Mod(new Man());
    }

    public static void Mod(Person person){
        person.eat();
    }

这种方法的定义在实际开发中是最常见的。

6.修饰符

6.1 static修饰符

static修饰的变量就是静态变量。随着类的加载而加载，可以通过类名直接访问
非静态变量属于对象，必须实例化才能访问。

public class Person {
    private String name;
    private int age;

    public static String test1 = "11";
    public String test2 = "22";

    public void eat() {
        System.out.println("吃");
    }
}

        System.out.println(Person.test1);
        System.out.println(new Person().test2);

static修饰的方法就是静态方法。静态方法是属于类的，通过类名调用即可。
非静态方法属于对象，需要实例化调用。

public class Person {
    private String name;
    private int age;

    public static String test1 = "11";
    public String test2 = "22";

    public static void play() {
        System.out.println("玩");
    }

    public void eat() {
        System.out.println("吃");
    }
}

   public static void main(String[] args) {
        Person.play();
        new Person().eat();
        new Person().play();
    }

当然用对象调用静态的变量和方法也行。

注意点

静态方法不可以直接访问类非静态变量和非静态变量。
this和super在类中属于非静态的变量.(静态方法中不能使用)

在这里插入图片描述

6.1.2 匿名代码块和静态代码块

匿名代码块是在创建对象的时候自动执行的,并且在构造器执行之前。同时匿名代码块在每次创建对象的时候都会自动执行.
静态代码块是在类加载完成之后就自动执行,并且只执行一次. 注:每个类在第一次被使用的时候就会被加载,并且一般只会加载一次

  {
        System.out.println("匿名");
    }

    static {
        System.out.println("静态");
    }

在这里插入图片描述
可以看出。匿名代码块每次创建对象都会调用。静态代码块只会在第一次被调用.

6.2 final修饰符

final最终的意思。

1.用final修饰的类不能被继承,没有子类。
2.用final修饰的方法可以被继承,但是不能被子类的重写。
3.用final修饰的变量表示常量,只能被赋一次值.其实使用final修饰的变量也就成了常量了,因为值不会再变了。

final double PI = 3.24;

6.3 abstract修饰符

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那
么该类就是抽象类。

抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

public abstract class AbsClass {

    public static void play(){
        System.out.println("play");
    }
    
}

public abstract class AbsClass {
    public abstract  void play();

}

子类继承抽象类后,需要实现抽象类中没有实现的抽象方法,否则这个子类也要声明为抽象类。

public class ChiClass extends AbsClass {
    @Override
    public void play() {
        
    }
}

7.接口 interface

和抽象类类似，接口只定义规范，需要实现类去实现。

public interface InterClass {
    public void play();
    public void eat();
}


public class ChiClass implements InterClass{

    @Override
    public void play() {
        
    }

    @Override
    public void eat() {

    }
}

7.1 接口与抽象类的区别

构造方法：
抽象类有构造方法，接口没有。
成员变量：
抽象类可以是常量也可以是变量
接口只能是定义常量，用public static final修饰
成员方法：
抽象类的方法可以是抽象的也可以不是
接口必须是抽象方法
继承关系：
类不可以多继承，接口可以多实现

接口方法不写修饰符也是默认的 public abstract

8. 内部类

8.1 成员内部类

public class NClass {

    public void outMod(){
        System.out.println("out");
    }
    //内部类
    class InClass{
        public void inMod(){
            System.out.println("in");
        }

    }
}

实例化比较麻烦

       NClass nClass = new NClass();
       NClass.InClass inClass = nClass.new InClass();

作用：访问外部类的私有成员变量，方法

8.2 静态内部类

public class NClass {

    public void outMod(){
        System.out.println("out");
    }
    //内部类
    static class InClass{
        public void inMod(){
            System.out.println("in");
        }
    }
}

可以直接实例化

       NClass.InClass inClass = new NClass.InClass();

静态内部类中可以声明静态方法和静态变量，但是非静态内部类中就不可以声明静态方法和静态变
量

8.3 局部内部类

public class NClass {

    public void outMod(){
        //内部类
         class InClass{
            public void inMod(){
                System.out.println("in");
            }
        }
    }
   
}

在方法中声明了一个内部类。

在局部内部类中，如果要访问局部变量，那么该局部变量要用final修饰

8.5 匿名内部类

什么是匿名对象？如果一个对象只要使用一次，那么我们就是需要new Object().method()。就可以了，而不需要给这个实例保存到该类型变量中去。这就是匿名对象。

  new Person().eat();

这种直接使用一次的，就不需要new一个对象了，这种写法就是匿名对象。
匿名内部类相同。

匿名内部类需要依托于其他类或者接口来创建
如果依托的是类,那么创建出来的匿名内部类就默认是这个类的子类
如果依托的是接口,那么创建出来的匿名内部类就默认是这个接口的实现类。
匿名内部类的声明必须是在使用new关键字的时候
匿名内部类的声明及创建对象必须一气呵成,并且之后能反复使用,因为没有名字。

我们使用之前的接口写一个匿名内部类实现接口并调用的写法。

    public static void main(String[] args) {
        new InterClass(){

            @Override
            public void play() {
                System.out.println("玩");
            }

            @Override
            public void eat() {

            }
        }.play();
    }
}

信小呆666

关注

0
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
java面向对象笔记

面向对象的本质就是：以类的方式组织代码，以对象的组织(封装)数据。抽象：就是抽出具象化的东西三大特点：封装，继承，多态。我们面向对象，就是把一个一个抽象的事务具象化一个类，然后把属性和行为定义出来。定义类这就是一个类，小猫的名字和年龄是它本身的属性，吃是小猫的行为类是一种抽象的数据类型，而对象是对这种抽象的类的实例化。2.类详解2.1 this关键字this翻译出来就是这个，每一个类都有一个this，他是一个引用。通常情况下可以省略。在实例方法中，或者构造方法中，为了区分局部变量和实例变量，不
复制链接

扫一扫

专栏目录