Java面向对象

目录

类与对象

类的定义

属性

方法

创建对象

对象的引用

权限修饰符

构造方法

方法重载

this关键字

static关键字

单例模式

---

类与对象

类：同一类型对象(事物)的抽象描述，定义了这一类对象共同的静态和动态属性

对象：计算机语言对一个具体事务的描述，静态属性(成员变量)和动态属性(方法)的封装体

属性：事物的静态方法  静态是指固定描述 并非固定值

方法：事物的动态行为   例如：后天学会的技能

类和对象的关系：类是对象的抽象(一组具有共同特征的对象的模板)，对象是类的具体实例

(类是对象的抽象，对象是类的实例，对象有具体的值，类不能，类变成对象的过程叫做实例化)

类的定义

使用关键字class定义类

组成：成员变量和成员方法

成员变量：类的属性

成员方法：类的行为

java文件(类文件)要求：

1.可以有一个或零个由public修饰的类

2.public修饰的类的名字必须与类文件名相同(包括大小写)

3.无public修饰的类不允许跨报访问、

4.可以有一个或多个类

5.一个类可以生成一个字节码文件(.class文件)

(注意：一个类文件可以生成一个字节码文件这句说法是错的，原因是一个类文件中可以出现多个类，所以可以生成多个字节码文件)

属性

属性又叫成员变量、数据成员、实例变量、全局变量

java中一共有九种数据类型，其中八种是基本数据类型，第九种是引用类型也可以称为对象类型，除八种基本数据类型以外的所有类型都可以被称为引用类型

属性定义形式为：权限修饰符 类型 成员名;

//例
private int a;//定义的时候不赋值会在创建对象的时候默认赋值
public char name = 'Zhang';//定义的时候直接赋值，被称为显示初始化

权限修饰符private修饰的成员变量，只能在本类中访问，因为具有封装性

方法

定义形式：修饰符 返回值类型 方法名 ([参数类型 参数名]){方法体语句}；\

//方法的小括号中有参数的方法被称为有参方法，没有参数的方法被称为无参方法
 public int method(int a,int b){//参数是多个的时候用","分割开
    //方法中不能嵌套方法就是不能定义方法  但是可以使用方法 但有注意事项
    //返回值类型是九种数据类型的方法，需要使用return 返回值的形式， 返回数据， 不写会编译报错
    //返回值和返回值类型的数据类型要求一致或者可以进行隐式转换
    return 10;
}

 public void method(){
    //当方法的返回值类型是void的时候，可以使用return返回，也可以不写return，
    //但是写了return不能再其后面写值，否则编译报错
}

 实体类(标准封装类)

Java的三大特性：封装、继承、多态

封装：属性私有化，为外部提供获取属性的get和set方法

public int age = 18;
private String name = "玫瑰";
public int getAge() {
    return age;
}

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

public String getName() {
    return name;
}

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

创建对象

创建对象的一般形式：

类名 对象名 = new 类名([参数])；

Student student = new Student();

创建对象的步骤：

1.为对象在堆区中创建内存并初始化成员变量为默认初值

2.执行属性显式初始化

3.执行构造方法

4.对象的引用赋值给引用变量

对象的引用

引用对象(实例)中属性和方法的一般形式

使用对象：用“.”进行操作

访问对象属性：对象名.属性(多个引用变量的同名属性在内存中有多个拷贝)

调用类的方法：对象名.方法名(多个引用变量的同名方法在内存中只有一个)

成员变量与局部变量

当局部变量与成员变量同名时会屏蔽成员变量

方法的调用

//形参：方法定义的时候写在括号中的参数，没有真实的值
//实参：方法调用的时候写在括号中的参数，有真实的值
//永远不变的是实参给形参赋值
public class Number {
    public void test(int x, int y){
        int temp = x;
        x = y;
        y = temp;
    }

    public static void main(String[] args) {
        int a = 3, b = 5, c = 0;
        Number n = new Number();
        n.test(a,b);
        System.out.println("a=" + a + "b=" + b);
    }
}
//值传递：传递的是八种基本数据类型，传递之后不会对原来变量本身有影响   传递的是值 所有对变量没有影响
//引用传递：传递的是引用类型的数据，传递之后可能会对原来的对象有影响
//java中只有值传递 没有真正意义上的引用传递

权限修饰符

构造方法

构造方法是类中一种特殊的方法，用于对象的初始化工作

注意事项：

1.方法名必须和类名相同，包括大小写

2.构造方法不能使用返回值类型修饰(如果写了不报错，但会转变为普通方法)

3.如果类中没有显式定义则编译器会自动生成无参的构造方法，如果有显式定义则不会增添无参的构造方法

方法重载

方法重载：对于类的方法，如果有两个方法方法名相同，但是参数不同，则一个方法被称为另一个方法的重载方法

注意事项：

1.必须在同一个类中

2.方法名相同

3.参数的个数、类型、顺序至少有一个不同

4.方法的权限修饰符可以不同

5.方法的返回值类型可以不同

重载方法的调用：

利用调用时候的实参数区分调用的是哪个重载方法

方法的实参与形参类型相同或兼容(可以进行转换)、个数相同、顺序一致

this关键字

特殊变量rhis代表对象本身

用法：

1.当全局变量和局部变量同名的时候，可以使用this调用全局变量从而解决屏蔽问题

2.在一个构造方法种调用其他的构造方法

3.在一个实例方法内，访问当前实例的引用（作为方法的实参传递）

public class ThisTest {
    private int age;
    private String name;
    public ThisTest(int age) {
        this.age = age;
    }
    //this关键字的第二种用法：在一个构造方法种调用其他的构造方法
    public ThisTest(int age, String name) {
        this(age);
        this.name = name;
    }

public class ThisTest01 {
    //主调方法：主动调用其他方法的方法
    //被调方法：被其他方法调用的方法
    //this关键字第三种用法：在一个实例方法内，访问当前实例的引用（作为方法的实参传递）
    //谁调代表谁
    public void doSomething(){
        System.out.println("doSomething中的this:"+this);
        saySomething(this);
    }
    public void saySomething(ThisTest04 thisTest04){
        System.out.println("saySomething中的thisTest04:"+thisTest04);
    }

    public static void main(String[] args) {
        ThisTest04 t = new ThisTest04();
        t.doSomething();
        System.out.println("main中的t:"+t);
        ThisTest04 t1 = new ThisTest04();
        t1.doSomething();
        System.out.println("main中的t1:"+t1);
    }
}

this在调用其他方法的时候必须写在第一行上，否则编译报错

static关键字

static修饰的变量、常量只能定义在类中(没用局部静态变量、常量)

static修饰的变量、常量、方法可以用类直接调用(推荐使用)，也可以用对象调用

static修饰的变量、常量、方法只属于某个类，而不属于某个对象，是这个类的对啊行所共享

静态变量：(静态变量又叫类变量还叫静态属性)

由static修饰的成员变量，也成为类变量、静态属性等

只能在类加载时被初始化一次，初始化为该类型默认值

不能在方法中定义

引用：

类名.变量名

对象名.变量名

静态常量：

必须在定义时初始化，且只在类加载时被初始化一次

不能在方法中定义

引用：

类名.常量名(推荐使用)

对象名.常量名

静态方法：

1.静态方法中不能直接调用非静态属性和非静态方法，可以直接调用静态属性和静态方法

2.非静态方法中可以直接调用非静态属性，非静态方法，静态属性和静态方法

3.如果要在静态方法中调用非静态的成员需要创建对象进行间接调用

引用：

类名.方法名(推荐使用)

对象名.方法名

(因main方法是静态方法，所以可以在其它类中直接调用)

static块：

static{
    语句块;
}

用于类的初始化

在类加载时执行(在对象创建前执行)，且执行一次

块中不能使用默认外的其它修饰符进行修饰

不能定义方法

单例模式

单例模式分为懒汉式和饿汉式两种

单例模式也叫单子模式，属于创建模式

懒汉式

//单例类需要条件
//1.构造方法私有化
//2.通过公有的静态方法将创建的对象返回
//3.通过属性私有化

public class Single {
    //需要将变量定义成全局变量，这样不会在方法调用完直接销毁，使用static原因是静态方法中不能直接调用非静态的属性
    //static 静态方法中只能调静态属性
    private static Single single = null; //属性私有化防止在外部赋值为null   属性在外部获取后不能新创new但可以销毁null
    //构造方法私有化，让其在类的外部一个对象都不能创建
    private Single(){}
    //我们可以在类的内部创建对象，通过方法返回
    //因为类的外部不能创建对象，所以只能选择静态方法进行返回对象
    public static Single getSingle(){
        //single 局部变量  调一次就释放了
        if(single == null){
            single = new Single();
        }
        return single;
    }
}

饿汉式

public class Single{
    private static Single single = new Single();
    private Single(){}
    public static Single getSingle(){
        return single;
    }
}

懒汉式和饿汉式区别