牛逼笔记：java面向对象一

Java是面向对象的程序设计语言，提供了定义类、成员等基本的功能，类可以理解为一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，他们会引用到类的对象。

类是用于描述客观世界里某一类对象的共同特征，对象则是类的具体存在，java使用构造函数来创建该类的对象

面向对象的特征：

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

1.      
类与对象

l        类是对象的描述，对象是类的实例。执行者———》》》》指挥者

1.1.     定义类

[修饰符] class 类名

{

    成员;

    构造函数；

    方法;

}

1.2.     定义成员

[修饰符] 成员类型 成员名 [=默认值];

private int age = 18；

修饰符：java提供了3个private、protected、public、还有一个默认省略的修饰符，修饰成员，方法等，且只能出现其一，可以static final组合使用。

	Private	Default	Protected	Public
同一个类中	√	√	√	√
同一个包中		√	√	√
子类中			√	√
全局范围内				√

1.3.     定义方法

[修饰符] 方法返回值类型 方法名（形参列表）

{

    方法体（可无）；

}

方法的修饰符：可以省略，可以使public、protected、private、static、final、abstract。前三者只能出现一个，后两者只能出现一个。

方法返回值类型：可以使基本数据类型和引用类型；如果声明了方法的返回值，则方法体内必须有一个有效的return语句，返回一个与声明相同类型的变量或者表达式。Void：表示无返回值。

形参列表：0到多个，中间用逗号隔开形参类型与形参名空格隔开。

方法体执行顺序：排在方法体前面的先执行，后面的后执行。

1.4.     对象的创建及其内存分配   

class Car//对Car这类事物进行描述

{

    Stringcolor = "red";

    intnum = 4;

    voidshow()

    {

        System.out.println("color="+color+"..num="+num);

    }

}

class CarDemo

{

    publicstatic void main(String[] args)

    {

        Carc1 = new Car();//声明并创建对象

c1.color="blue";//修改对象的属性

Car c2 = new Car();//声明并创建对象c2

    }

}

1.5.     this的概念

特点：this代表其所在函数所属对象的引用。

换言之：this代本类对象的引用。

什么时候使用this关键字呢？

方法中局部变量和成员变量重名，想调用成员变量时就可以使用this.变量名形式访问成员变量。

在方法中要将调用该方法的对象作为参数传递给另一个方法时，可以将this作为实参传给该方法。

在内部类中访问外部类的成员时，需要使用外部类名.this.成员名形式访问。

例：

class Person{

int age;

Person(int age)

{

this.age = age;

}

}

1.6.     
对象与二维数组的内存分配图

 

 

2.      
方法

l      方法只能定义在类里，不能独立定义。

l      方法要么属于类，要么属于该类的某个对象。

l      永远不能独立执行方法，执行方法必须使用类或者对象作为调用者

l      函数的特点：

可将功能代码进行封装

便于对该功能进行复用

l      2个明确 

返回类型的确定；这个功能实现过程中是否需要未知参数参与预算

2.1.     方法的参数传递

Java按值传递。

例如：

class Demo{

public static void main(String[] args)//主函数入口

    {      

        int n = 9;

getDemo99(n);//调用九九乘法表函数

    }

public static void getDemo99(int n)//将9传递给int型的n

    {   //forfor循环，根据传递的参数，打印乘法表

        for (int i= 1;i <= n;i++ )//外层循环控制行数

        {

            for(int j = 1;j <= i ;j++ )//内层循环控制列数

            {

                System.out.print(j+"*"+i+"="+(i*j)+"\t");

            }

            System.out.println();

        }      

    }

}

2.2.     递归方法

一个方法本身调用自己，这个方法就被成为递归方法。原则：向已知方向递归。

/*

已知：f(0)=0,f(1)=4,f(n+2)=2*f(n+1)+f(n),其中n是大于0的整数，求f（10）

分析：f0 f1已知，所以要想小的方向递归，设x=n+2，即n=x-2，带入公式得到：

 f(x)=2*f(x-1)+f(x-2);

 */

publicclass Recursive

{

     public static int fn(int n)

     {

         if (n == 0)

              return 1;

         else if (n == 1)

              return 4;

         else    

              //方法中调用它自身，就是方法递归

              return 2 * fn(n - 1) + fn(n - 2);

     }

     public static void main(String[] args)

     {

         //输出fn(10)的结果

         System.out.println(fn(10));

     }

}

2.3.     方法重载

同一个类中允许多个同名函数存在，函数的重载和返回值类型修饰符无关。即同名不同参。（包括参数个数，参数顺序）

class Chongzai

{

    voidshow()

    {

        System.out.println("show");

    }

    voidshow(int n)

    {

        System.out.println("show"+n);

    }

}

2.4.     变量：成员变量VS局部变量

 
                            实例成员（不以static修饰）
成员变量
                            类变量（以static修饰）
变量
                           
形参（方法传值定义的变量）
局部变量     方法局部变量（方法内部定义）
                            代码块局部变量（代码块内定义）

 

 

区别：

1： 成员变量定义在类中，整个类中都可以访问

局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。

2： 成员变量存在于堆内存的对象中

局部变量存在于栈内存的方法中

3： 成员变量随着对象的创建而存在，随着对象的消失而消失

局部变量随着区域的执行而存在，随着所属区域的结束而释放

4： 成员变量都有默认初始化

    局部变量必须初始化。

2.5.     Main函数详解

public static void main(String[] args)

主函数特殊之处：

1，格式是固定的。

2，被jvm所识别和调用。

public:因为权限必须是最大的。

static:不需要对象的,直接用主函数所属类名调用即可。

void：主函数没有具体的返回值。

main:函数名，不是关键字，只是一个jvm识别的固定的名字。

String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

3.      
三大特性一：封装（encapsulation）

l        隐藏对象的信息，不允许外部程序直接访问，而是通过该类所提供的方法来实现对内部信息的操作

3.1.     封装的特点及原则

好处：

•        将变化隔离。

•        便于使用。

•        提高重用性。

•        提高安全性。

封装原则：

•        将不需要对外提供的内容都隐藏起来。

•        把属性都隐藏，提供公共方法对其访问。

3.2.     访问控制修饰符

Java提供了3个访问控制符：private、protected、public，还有一个默认的一共四个访问控制级别

控制访问级别表：

	Private（当前访问权限）	Default（包访问权限）	Protected（子类访问权限）	Public（公共访问权限）
同一个类中	√	√	√	√
同一个包中		√	√	√
子类中			√	√
全局范围内				√

 

Private（当前访问权限）：将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访问的安全性

Protected：子类可访问，通常是希望子类重写方法。

Public：通常提供对外方法，来访问被被封装的数据。

public class Person

{

     //将Field使用private修饰，将这些Field隐藏起来

     private String name;

     private int age;//提供方法来操作age Field

     public void setAge(int age)

     {       

         if (age > 100 || age < 0)//执行合理性校验，要求用户年龄必须在0～100之间

         {

              System.out.println("您设置的年龄不合法");

              return;

         }

         else    

              this.age = age;       

     }

     public int getAge()

     {

         return this.age;

     }

}

3.3.     构造函数

构造函数（Constructor）是一个特殊的函数。用于创建实例时执行初始化，是创建对象的重要途径，因此java类必须包含一个或一个以上的构造函数。

l        构造函数VS一般函数

构造函数：创建对象时，就会调用与之相应的构造函数，来给对象初始化

一般函数：创建对象后，需要函数功能时才调用

l        构造函数重载

同一个类里有多个构造函数，他们的形参列表不同，即被称为构造函数的重载。

l        默认构造函数

每一个类都有构造函数，即使我们没有显式定义构造函数，也会生成一个默认无参的构造函数，其中没有任何内容。

注意：如果我们定义了一个有参的构造函数，那么就没有默认构造函数了

3.4.     静态特点及注意事项

特点：

    是一个修饰符，用于修饰成员

    静态修饰的成员被所有对象所共享，存储的是共享数据，而非静态存储的是对象特有数据

    静态优先于对象存在，因为static的成员随着类的加载就已经存在

    静态修饰的成员可以用类名.静态变量直接调用

 

注意事项：

    静态方法只能访问静态成员（非静态方法既可以访问静态也可以访问非静态）

    静态方法不可以使用this和super关键词

    主函数是静态的 

3.5.     静态VS非静态

static关键字用来修饰类的成员，被这个关键字修饰的成员都和类加载有关。

JVM运行时不会将所有类加载到内存，因为无法确定程序中要使用哪些。类在第一次使用时加载，只加载一次。

静态不能调用非静态（静态在的时候，非静态还不在内存中存在呢）

3.6.     静态什么时候用？

1，静态变量。

    当分析对象中所具备的成员变量的值都是相同的 。

    这时这个成员就可以被静态修饰。

    只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

    如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

 

2，静态函数。

    函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。

    简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

    如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，

    但是非静态需要被对象调用，而仅创建对象调用非静态的

    没有访问特有数据的方法，该对象的创建是没有意义。

 

3.7.     静态代码块的特点和作用？

特点;随着类的加载而执行。而且只执行一次。

作用：用于给类初始化。

扩展：  局部代码块：对局部变量的生命周期进行控制。

    构造代码块：对所有对象进行初始化。

3.8.     单例设计模式

解决的问题，以及设计思想。代码体现，全部都要会！

解决的问题：

    解决的问题：就是可以保证一个类在内存中的对象的唯一性。

    必须对于多个程序使用同一个配置信息时，就需要保证该对象的唯一性。

解决方法：

    1：不允许其他程序用new创建该类对象；

    2：在该类创建一个本类实例。

    3：对外提供一个方法让其他程序可以获取该对象

步骤：

    1：私有化该类的构造函数

    2：通过new关键字在本类中创建一个本类对象。

    3：定义一个public的方法，将创建的对象返回。

恶汉式：先加载

class Single

{

     private static Single s = new Single();

     private Single(){}

     public static Single getInstance()

     {

         return s；

     }

}

懒汉式：延迟加载

public class Single2 {   

    private static Single2 sing;

    private Single2() { }   

    public static Singleton getInstance() {

        if (sing == null) {

            sing = new Singleton();

        }

        return sing;

    }

}