面向对象（总结）

最新推荐文章于 2024-07-22 22:58:19 发布

lzpyy

最新推荐文章于 2024-07-22 22:58:19 发布

阅读量25

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/lzpyy/article/details/133163619

版权

成员变量：类中方法外的变量（成员变量在堆内存中，随对象存在而存在）

局部变量：方法中的变量（局部变量在栈内存中，随着调用完毕而消失）

封装：

合理暴露，合理隐藏，好处是安全性、复用性

this：

this关键字代表当前对象，通常用于区分成员变量和方法中的局部变量；修饰的变量用来指代成员变量

构造方法：

分为有参和无参构造两种，推荐都写上（如果没定义构造方法，系统将给出一个默认的无参数构造方法，如果定义了，还要使用无参构造，就必须再写一个无参构造）

修饰类：

public：项目在任何地方都可以访问

protected：同包下任意类包括其子类

private：只能自身访问（不允许外部程序直接访问，通过get/set方法访问）

package-access（缺省）：同包下任意类

equals：

char[] chars={'a','b','c'};
String str1=new String(chars);
String str2=new String(chars);
String str3="abc";
String str4="abc";
System.out.println(str1==str2); //false
System.out.println(str1==str3); //false
System.out.println(str3==str4); //false
System.out.println(str1.equals(str3)); //false
System.out.println(str3.equals(str4)); //false

StringBuilder:

对字符串进行拼接操作每次拼接都会构建一个新的String对象，耗时又浪费内存空间，而StringBuilder是可变的字符串类。

包含了增加、改、反转等操作,如下：

public static void main(String[] args) {
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("hello");
        stringBuilder.append("world");
        System.out.println(stringBuilder);//helloworld
        stringBuilder.append("hi").append("hi");
        System.out.println(stringBuilder);//helloworldhihi
        stringBuilder.replace(0,4,"aaaa");
        System.out.println(stringBuilder);//aaaaoworldhihi
        StringBuilder stringBuilder1=new StringBuilder();
        stringBuilder1.append("hello").reverse();
        System.out.println(stringBuilder1);//olleh
}

String和int互转：

int->String:String str=String.valueOf(num);

String->int: int a=Integer.parseInt(str);

String和StringBuilder互转：

public String toString()

public StringBuilders(String s)
StringBuilder sb=new StringBuilder();
sb.append("hello");
String s=sb.toString();
System.out.println(s);   //hello
StringBuilder str=new StringBuilder(s);
System.out.println(str); //hello

继承：

可使得子类具有父类(超类、基类)的属性和方法，还可以在子类中重新定义，追加属性和方法

格式：public class 子类名 extends 父类{}

有类不一定有对象，有对象一定有类；static属于类的东西，非static属于对象的东西

所有类的父类都是Object，Object的能重写的方法都可以被重写(equals、hashCode、toString)

类中可声明内容：

静态初始化器、实例初始化器、构造方法、成员变量、成员方法、成员类、成员接口

关与可不可被继承：

同包下，可被继承的有非private的1成员（变量、方法、成员类、成员接口等）

不同包下，可被继承的有public及protected修饰的成员（变量、方法、成员类、成员接口等)

一定不能被继承的有静态初始化器、实例初始化器、构造方法、私有属性、私有方法、私有成员类、私有成员接口等。

继承的优缺：

好处：提高复用性（多个类相同的成员可以放在同一个类中)

提高维护性(需要修改、改一处即可)

弊端：削弱了子类的独立性

继承中变量访问特点：在子类中访问一个变量：1.子类局部范围 2.子类成员范围 3，父类成员范围

this和super的区别：

1.this指代当前对象，super指代父类对象

2.this可以解决变量遮蔽问题，super解决隐藏问题

3.this调用属性或方法时，本类没有可以调用父类的；super调用父类的属性或方法

4.this可以在任何类中使用；super出现在子类中

5.都只能在实例方法、构造方法或实例初始化器中使用

6.都可以表示构造方法的调用，并且只能在构造方法的第一行，不能同时出现；如果子类构造中调用父类无参构造方法时，super可省略。

继承中构造方法的访问特点：

子类中所有的构造方法默认都会访问父类中无参的构造方法：

因为子类先会继承父类的数据，可能还会使用父类的数据，所以子类初始化前先完成父类数据初始化。

每个子类构造方法的第一条语句默认：super();

如果父类中没有无参构造，只有带参构造：通过super关键字去显示的调用父类的带参构造方法；

在父类中自己提供一个无参构造方法（推荐：自己给出无参构造）

方法重写：

概述：子类中出现了和父类一样的方法声明

应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样即沿袭了父类功能，又定义了子类内容

注意：私有方法不能被重写（父类私有成员，子类不能继承）

类只支持单继承，支持多层继承

final关键字：

修饰方法：表明该方法是最终方法，不能被重写（可被继承）

修饰变量：表明该变量是常量，就不能被再次赋值

修饰类：表明该类是最终类，不能被继承

static关键字：

1.static表示静态的，可以用来修饰类、接口、方法、字段和代码块

2.使用static修饰的是静态，属于类，多个实例（对象）之间共享；没有static修饰的是非静态的，属于实例。

3.static修饰的成员都可以使用类名直接调用（推荐），也可以通过对象名调用。static成员直接可以相互访问，但不能访问实例成员。实例成员可以访问static成员。

4.类首次加载的时候，会初始化static成员。

重载和重写的区别：

1.在同一类中，存在方法名相同，参数列表不同（顺利、个数、类型）的方法称为重载。

2.在继承关系中，子类声明一个继承父类的方法名相同、参数列表相同、返回值类型一致、访问修饰符相同或变大、抛出异常相同或缩小的方法称为重写。

3.重载是编译时多态，重写是运行时多态。

多态：

概述：同一对象在不同时刻表现出的不同形态

public class Animal{
    public int age=20;
    public void eat(){
        System.out.println("动物吃东西");
    }
}
//-----------------------------------------
public class Cat extends Animal{
    public int age=10;
    public int weight=30;
    public  void eat(){
        System.out.println("猫吃鱼");
    }
    public void play(){
        System.out.println("玩毛线");
    }
}
//-----------------------------------------
public class Test {
    public static void main(String[] args) {
        Animal a=new Cat();
        System.out.println(a.age);//20
        a.eat();
        //a.play();
    }
}