java面向对象笔记

炒鸡冲冲冲

已于 2022-04-05 17:29:51 修改

阅读量151

点赞数

文章标签： java intellij-idea

于 2022-02-08 20:19:15 首次发布

本文链接：https://blog.csdn.net/m0_51358501/article/details/122830464

版权

1、java类及类的成员：属性、方法、构造器；代码块、内部类

2、面向对象的三大特征：封装性、多态性、继承性、（抽象性）

3、其他关键字：this、super、static、final、abstract、interface、package、import等

设计类，其实就是设计类的成员

属性	成员变量	field	域、字段
方法	成员方法	method	函数

一、类的成员使用：

1、类的属性

属性（成员变量） vs 局部变量

1）、相同点：

1.1、定义变量的格式：数据类型变量名=变量值

1.2、先声明，后使用

1.3、变量都有其对应的作用域

2）、不同点：

2.1、在类中声明的位置不同：

成员变量：直接定义在一对{}中。

局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。

2.2、关于权限修饰符的不同：

成员变量：可以在声明属性时，指明其权限，使用权限修饰符。常用的权限修饰符: private、public、缺省、protected 。

局部变量：不可以使用权限修饰符。

2.3、默认初始化值的情况:
成员变量：类的属性，根据其类型，都有默认初始化值。

局部变量：没有默认初始化值。意味着,我们在调用局部变量之前，一定要显式赋值，特别的：形参在调用时,我们赋值即可。

2.4、在内存中加载到的位置：

成员变量：加载到堆空间中。（非static ）

局部变量：加载到栈空间中。

java中一个源程序只能有一个public类的存在。java程序是从main方法开始执行的，public为类加载器提供入口，然后找到public类中的main方法进行执行，如果存在多个public类，程序就不知道从哪进入。

2、类的方法

1、方法的声明

权限修饰符返回值类型方法名 ( 形参列表 ){ 方法体 }

注意:static、final、 abstract来修饰的方法

3.1、关于权限修饰符：默认方法的权限修饰符先都使用public

Java规定的4种权限修饰符: private.public、缺省、protected

如果权限修饰符用来修饰类的话，只能使用缺省和public

3.2、返回值类型:有返回值vs没有返回值

3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。

同时，方法中，需要使用return关键字来返回指定类型的变量或常量:“return数据”。

如果方法没有返回值，则方法声明时，使用void来表示。

3.4 形参列表:方法可以声明0个，1个，或多个形参。

格式:数据类型1 形参1,数据类型2形参2,...

2、方法的重载

1)重载的概念：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

记忆方法：两同一不同，相同类，相同方法、不同参数列表。

2)重载的特点∶

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

3)重载示例:

l返回两个整数的和
int add(int x,int y){return x+y;}/返回三个整数的和
int add(int x, int y,int z){return x+y+z;}返回两个小数的和
double add(double x,double y){return x+y;}

3、方法的重写

1.重写:子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

2.应用:重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

重写的规定:
        方法的声明:权限修饰符返回值类型方法名 ( 形参列表 ){
                                方法体
                                }

子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

>特殊情况:子类不能重写父类中声明为private权限的方法

返回值类型:

>父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void

>父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类

>父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的
(不是重写)

3、类的构造器（构造方法）

1、构造器的作用：

1）.创建对象

2）.给对象进行初始化

2、说明：

1）.如果没有显式的定义类的构造器的话，则系统默认提供—个空参的构浩器

2）.定义构造器的格式:权限修饰符类名(形参列表){}

3）.一个类中定义的多个构造器，彼此构成重载

4）.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

5）.一个类中至少有一个构造器

4、内部类

1、java中允许将一个类A声明在另一个类B中，类A就是内部类，类B就是外部类。

2、内部类的分类：成员内部类（静态、非静态） vs 局部内部类（构造器内、代码块内、方法内）。

3、成员局部类：

一方面作为外部类的成员：

1、调用外部类的结构

2、可以被static修饰

3、可以被四种不同的权限修饰

另一方面，作为一个类：

1、类内可以定义属性、方法、构造器等。

2、可以被final修饰，表示该类不能被继承。

3、可以被abstract修饰。

5、可变个数的形参

1）、可变个数形参的格式：数据类型 ... 变量名 xxx（String ... str）{}

2）、当调用可变个数形参的方法时，传入的参数个数可以是:0个，1个，2个，。。

3）、可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

4）、可变个数形参的方法与本类中方法名相同，和形参类型也相同的数组之间不构成重载。换句话说，二者不能共存 （String[] str 和 String ... str不能共存）

5）、可变个数形参在方法的形参中，必须声明在末尾。 （int a,String ... str）声明末尾

6）、可变个数形参在方法的形参中,最多只能声明一个可变形参。

6、this的使用

1、this可以用来修饰：属性、方法、构造器

2、this修饰属性方法：this理解为当前对象或当前正在创建的对象

1）在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3、this调用构造器：

1）我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器

2）构造器中不能通过"this(形参列表)"方式调用自己

3）如果一个类中有n个构造器，则最多有n - 1构造器中使用了"this(形参列表)"

4）规定:"this(形参列表)"必须声明在当前构造器的首行

5）构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

public class PersonTest(){
    main(){
    Person p=new Person(11);
    
    }
}

class Person(){
    int age;
public Person(){
    System.out.print("这是空参");
}

public Person(int age){
    this();   //调用空参构造器
    this.age=age;   //调用属性
}
}

7、super的使用

1、super可以用来调用：属性、方法、构造器

2、super可以理解为：父类的

3、super的使用调用属性和方法

1）我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显

式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."

2）特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式,表明调用的是父类中声明的属性。

3）特殊情况:当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

4、super调用构造器

1）我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器

2） "super(形参列表)"的使用，必须声明在子类构造器的首行!

3）我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现

4）在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器（ super() ）

8、对属性赋值的顺序

1.默认初始化——> 2.显性初始化 / 在代码块中赋值——>3. 构造器中初始化——>4.有了对象后可以通过“对象.属性”或“对象.方法”的方式，进行赋值

优先级：

静态成员变量或静态的代码块---》main方法 ---》非静态成员变量或非静态代码块---》构造方法

9、参数的值传递

方法的值传递，引用类型传递的是地址值，基本数据类型传递的是值。

二、内存解析

堆（heap）：用于存储对象实例等。

栈（stack）：用于存储局部变量等。

方法区：用于存储已被虚拟机加载的类信息、常量、静态变量等。

三、匿名对象的使用

1.理解:我们创建的对象，没有显式的赋给一个变量名。即为匿名对象

2.特征:匿名对象只能调用一次。

四、JavaBean

所谓的javaBean，是指符合如下标准的java类：

1、类是公共的

2、有一个无参的公共构造器

3、有属性、且有对应的get() set()方法

五、面向对象的三大特征

1、封装性

1）封装性的体现：

我们将类的属性xXx私有化(private),同时提供公共的(public)方法来获取(getXxx)和设置

(setXxx)

封装性的体现:①如上 ②不对外暴露的私有的方法 ③单例模式...

2）封装性的体现需要权限修饰符来配合

1.Java规定的4种权限（从小到大排列): private、缺省、protected . public

2.具体的，4种权限都可以用来修饰类的内部结构:属性、方法、构造器、内部类

修饰类的话，只能使用:缺省、public

2、继承性

1、继承性的好处：

1）、减少代码冗余，提升代码复用性

2）、便于功能的扩展

3）、为之后多态的使用提供了前提

2、继承性的格式： class A extends B { }

A:子类、派生类、subclass
B:父类、超类、基类、superclass

体现：一旦A类继承父类B之后，子类A就获取了父类B的所有属性和方法（包括private）

3、java中关于继承性的规定：

java只支持单继承和多层继承，不支持多重继承

4、

1．如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.0bject类

2．所有的java类(除java.lang.object类之外）都直接或间接的继承于java.lang.0bject类

3．意味着，所有的java类具有java.lang.object类声明的功能。

子类对象实例化的全过程

1．从结果上来看:（继承性)

子类继承父类以后，就获取了父类中声明的属性或方法。创建子类的对象,在堆空间中,就会加载所有父类中声明的属性。

2．从过程上来看:

当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器,直到调用了java.lang.o0bject类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。

3、多态性

1、理解多态性：

可以理解为一个事物的多种形态。

2、何为多态性：

父类的引用指向子类的对象。

3、多态的使用：虚拟方法调用

有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，在运行后，调用子类重写父类的方法。

总结：编译看左边，运行看右边

4、多态的使用前提：

①类的继承关系 ②方法的重写

5、对象的多态性，只适用于方法，不适用于属性（编译和运行都看右边）

向下转型：

向下转型使用强制类型转换符。

//Person时Man的父类
Person p=new Man();
Man m1=(Man)p;    //向下转型  成功
WoMan w1=(WoMan)p; //向下转型 失败可能出现ClassCastException异常 
        //   所以就要引入instanceof关键字

向下转型失败可能出现ClassCastException异常就要引入instanceof关键字

instanceof关键字的使用

p instanceof m1：判断 p对象是否是类m1的实例，如果是返回true ，否则false

//Person时Man的父类
Person p=new Man();

if(p instanceof m1){    //true
    Man m1=(Man)p;    //执行  向下转型  
}
if(p instanceof w1){    //false
    WoMan w1=(WoMan)p;  //不执行
}

//就可以避免ClassCastException异常

首先A 是 B 的父类，如果p instanceof A 返回true ，那么p instanceof B也返回true

六、object的使用

1、equals()方法的使用：

1、equals是一个方法而非运算符。

2、只能适用于引用数据类型。

3、object类中equals方法的定义：

        public boolean equals(0bject obi) {
                return (this ==obi);
        }

说明：Object类中定义的equals方法和==的作用是相同的：比较两个数的地址值。

4、像String、Date、File、包装类等等都重写了Object中的equals方法。重写后比较的是两个对象的“实体内容”是否相同。

2、toString()方法的使用：

1、当我们输出一个对象的引用时，实际调用的是对象的toString

2. object类中toString()的定义:

public String tostring() {

return getClass( ).getName() +“@" + Integer.toHexString(hashCode())

}
3．像String、Date、File、包装类等都重写了0bject类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息

七、包装类的使用

为什么要使用包装类：

因为基本数据类型和Object没有任何联系，导致用不了Object中的方法，所以才需要使用包装类来使用Object中的方法

1、基本数据类型、包装类、String引用数据类型之间的转换：

int num=10；

Integer in=num；  // 自动装箱
int num1=in；//自动拆箱


基本数据类型和包装类转String类
//方式1：通过连接运算
int i = 1 ;
String str = i + "";

//方式2：调用string中的ValueOf(Xxx xxx)
String str1 = String.valueOf(i); 

String类转基本数据类型和包装类  调用包装类的parseXxx(String str)
String str2="123";
int i1=Integer.parseInt(str2);

Integer内部定义了IntegerCache结构,IntegerCache中定义了Integer[],保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了。

尝试的结果：

Double d1=12.0;
Double d2=12.0;
System.out.println(d1==d2); //false ，因为自动装箱其实是new的
Integer i1=123;
Integer i2=123;
System.out.println(i1==i2); //true ，123在-128~127之间所以自动装箱并不是new的

包装类之进制转换：

八、关键字的使用

1、static关键字的使用

1、static：静态的

2、static关键字用来修饰：属性、方法、代码块、内部类

3、使用static关键字修饰变量：静态变量（类变量）

        1）属性，按是否使用static修饰，又分为:静态属性vs非静态属性(实例变量)
                实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时,不会导致其他对象中同样的属性值的修改。
                静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

2） static修饰属性的其他说明:

静态变量随着类的加载而加载。

可以通过"类.静态变量"的方式进行调用静态变量的加载要早于对象的创建。

由于类只会加载一次，则静态变量在内存中也只会存在一份:存在方法区的静态域中。

4、使用static修饰方法：静态方法

静态方法随着类的加载而加载。

静态方法中只能调用静态的属性或方法，非静态的方法既可以调用静态的属性和方法也可以调用非静态的

5、static注意点：

在静态的方法内，不能使用this关键字，super关键字。

关于静态属性和静态方法，根据生命周期的角度去理解。

2、final关键字的使用

final关键字:最终的

1、final可以用来修饰的结构：类、方法、变量

2、final修饰类类不能被继承 如：String类、StringBuffer类、System类

3、final修饰方法方法不能重写。

4、final修饰变量 变量变为常量。

1）final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化。

2）final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量，当我们调用方法时，给常量形参赋一个实参。一旦赋值后，只能在方法体中使用该形参，不能进行重新赋值。

static final 用来修饰属性：全局常量

3、abstract抽象关键字的使用

abstract：抽象的

1、abstract用来修饰：方法、类

2、abstract修饰类：抽象类

1）此类不能实例化。

2）抽象类中一定会有构造器，便于子类实例化调用。

3）开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作。

3、abstract修饰方法：抽象方法

1）抽象方法只有方法的声明，没有方法体。

2）包含抽象方法的类，一定是抽象类。反之，抽象类中可以没有抽象方法。

3）若子类重写了父类中的所有抽象方法，此子类方可实例化。

若子类没有重写了父类中的所有抽象方法，那么此子类也是一个抽象类，需要使用abstract进行修饰。

abstract需要注意的点：

1、abstract不能用来修饰：属性、构造方法等结构

2、abstract不能用来修饰：私有方法、静态方法、final的类、final的方法

public abstract class A{  //抽象类
    public abstract fanfa();   //抽象方法
}

九、单例设计模式

1、所谓的单例设计模式，就是采取一定的方法保证在整个系统中，对于某个类只存在1个实例。

1、懒汉式

//懒汉模式      因为很懒所以只有要上的时候才new
public class Singletion {
    public static void main(String[] args) {
        Bank bank1 = Bank.getBank();
        Bank bank2 = Bank.getBank();
        System.out.println(bank1==bank2);    //true
    }
}
class Bank{
    //1、私有化构造器
    private Bank(){}
    //4、必须声明static
    //2、内部创建类的对象，但是并未初始化
   private static Bank bank=null;
    //3、提供公共的静态方法，返回类的对象
    public static Bank getBank(){
        if(bank==null){
            bank=new Bank();
        }
        return bank;
    }
}

懒汉式存在线程不安全所以要引用synchronized同步代码块或者同步方法

2、饿汉式

//饿汉模式     因为比较饿所以上来就new了个对象
public class Singletion {
    public static void main(String[] args) {
        Bank bank1 = Bank.getBank();
        Bank bank2 = Bank.getBank();
        System.out.println(bank1==bank2);    //true
    }
}
class Bank{
    //1、私有化构造器
    private Bank(){}
    //4、静态方法中只能使用静态的，将对象声明为静态
    //2、内部创建类的对象
   private static Bank bank=new Bank();
    //3、提供公共的静态方法，返回类的对象
    public static Bank getBank(){
        return bank;
    }
}

区分懒汉式和饿汉式：

单例模式	好处	坏处
饿汉式	线程安全	对象加载时间过长
懒汉式	延迟对象的创建	线程不安全（到多线程会优化）

十、接口的使用

1、接口使用interface来定义

2、java中，接口和类是并列的2个结构。

3、如何定义接口：定义接口中的成员

1）jdk7.0之前：只能使用全局常量、抽象方法

全局常量：public static final 的，但是书写的时候可以省略

抽象方法：public abstract 的书写的时候可以省略

2）jdk8.0：除了定义全局常量和抽象方法，还可以定义静态方法、默认方法 。。。

4、接口中不能定义构造方法！意味着接口不能实例化。

5、Java开发中，接口通过让类去实现(implements)的方式来使用.

如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化

如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

6、java类可以实现多个接口 ---》弥补了java的单继承性

格式：class AA extends BB implements CC,DD,EE

7、接口和接口之间可继承，可以多继承接口和接口之间叫继承、接口和类之间叫实现、类和类之间叫继承

格式：class AA extends BB,CC

静态方法和默认方法：

1、接口中的静态方法只能通过接口来调用，不能通过实现的类进行调用

2、通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，那么调用时，调用的是类重写过后的默认方法。

3、如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的方法,那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则

4、如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法,那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
这就需要我们必须在实现类中重写此方法

public interface A{
    int MAX=100; //全局常量
    void num();  //抽象方法
    public static void Xx(){.....} //静态方法
    public default void Xxxx(){...}//默认方法
    default void Xxxxx(){....}  //默认方法
}
class B implements A{
    public void num(){}
}

//USB 是接口 ，  AA是实现USB

//1.创建了接口的非匿名实现类的非匿名对象
AA aa = new AA();
//2．创建了接口的非匿名实现类的匿名对象
new Printer();
//3．创建了接口的匿名实现类的非匿名对象
USB phone = new USB(){
    @override
    public void start(){
        system.out. println("手机开始工作");
    }
};

// 4．创建了接口的匿名实现类的匿名对象
new USB(){
    @override
    public void start() {
        system.out.println( "xxx");
    }
}

炒鸡冲冲冲

关注

0
点赞
踩
0

收藏

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

java面向对象1、java类及类的成员：属性、方法、构造器；代码块、内部类2、面向对象的三大特征：封装性、多态性、继承性、（抽象性）3、其他关键字：this、super、static、final、abstract、interface、package、import等...
复制链接

扫一扫