面向对象（二）

最新推荐文章于 2024-01-25 15:46:07 发布

rensongling

最新推荐文章于 2024-01-25 15:46:07 发布

阅读量417

点赞数

分类专栏： JAVA 文章标签： javadoc string class 设计模式文档

本文链接：https://blog.csdn.net/rensongling/article/details/7650881

版权

JAVA 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

this关键字：

作用：用于区分局部变量和成员变量同名的情况

class person
{
String name;
public person(String name)
{
name=name;
}
}
下一个
class peson
{
Strng name;
publicperson(String name)
{
this.name=name;
}
}这两个代码就充分的说明了他的作用区分成员变量和局部变量

this：创建对象时那一个对象在调用this所在的函数，this就代表那一个对象。

this的应用：当定义类中的函数时，该函数内部要用到调用该函数的对象时

这时用this来表示这个对象

this（）语句：用于构造函数之间的互相调用。

注：this（）必须放在第一句，初始化要先执行。

Person（String name）

{

this.name=”小王”;

}

Person p = new void Person(“小林”,18);

Person（String name int age）

{ this.name=name;

this();

this.age=age;

}

而输出的名字会是小王而不是小林，放到第一行，先给调用小王，再给他赋小林

函数的参数传递：

基本数据类型的参数传递

在传递过程中基本类型的变量做为实参传递。并不能改变这个值。

class passvalue
{
 public static void main(String[] args)
{
int x=5;
change(x);
}
public static void change(int x)
{
x=3;
}
}//就好比这里输出的值是5而不是3

引用数据类型的参数传递：

对象的引用变量不是对象本身它们只是对象的句柄一个对象可以有多个句柄。就好像一个人有中文名英文名...

java语句被调用方法的参数复制时只采用传值的方式，所以基本功数据的是该数据的值本身，引用类型数据传递的也是这个变量的值本身，即对象的引用（句柄）而非对象本身通过方法调用可以改变对象的内容，但是对象的引用是不能改变的对于数组，也属于引用数据类型可以将数组对象作为参数传递。【

statuc关键字：

静态变量：

用法：是一个修饰符，用于修饰成员变量和函数。

当成员被static袖手后，就多了一个调用方式，除了可以被对象调用歪，还可以直接被类名调用，类名.静态成员

static特点：1 随着类的加载而加载(也就说静态会随着类的消失而消失，生命周期最长)

2优先于对象存在 3被所有对象所共享 4可以直接被类名调用的

我们不能把任何何方法体内的变量声明为静态比如：

fun(){static int i=0;}

static 标识符修饰的变量，它们在类被载入的时创建，只要类存在static变量就存在。

静态成员变量能被各实例对象所共享。

类的静态成员经常被叫做“类成员”对于静态成员变量，我们叫“类的属性”对于静态成员的方法叫“类方法”

采用static关键字说明类的属性和方法不属于类的某个实例对象在程序中用的System.out.println()语句

System是一个类名out是System类的一个静态成员变量println（）方法则是out所引用的对象方法

System.gc()语句中的gc()也是System类的一个静态方法。

使用静态方法应该注意的：

1.在静态方法里只能直接调用同类中其他的静态成员（包括变量和方法）但是不能直接访问类中的非静态成员。

这是因为非静态的方法和变量需要先创建类的实例对象后才可以使用而静态方法在使用前不用创建任何对象。

2.静态方法不能以任何方式引用this和super关键字。因为静态方法在使用前不用创建任何实例对象，当静态方法

调用里this所引用的对象跟本就没有产生。

3.main()方法是静态的，因此在JVM执行main方法时不创建main方法所在的类的实例对象，因而在main（）方法中，不能直接访问该类的非静态成员，必须创建该类的一个实例对象才可以通过这个对象去访问类中的非静态成员。

静态代码块：

一个类中可以使用不包含在任何方法体中的静态代码块。当类被载入时静态代码块被执行，且只执行一次，静态代码块经常用来进行类属性的初始化。

class staticdemo
{
static String country;
static
{
country="shina";
System.out.println("Staticdemo is loading");
}
}
class staticdemo1
{
static
{
System.out.println("staticdemo1 is loading");
}
public static void main(String[] args)
{
System.out.println("begin executing main method");
new staticdemo();
new staticdemo();
}
}//结论类是在第一次被使用的时候才被装载的而不是在程序启动里就装载程序中据此有可能要用到的类这里尽管有两个实例对象但是其中的静态代码块只被执行了一次

单例设计模式：

让一个类在内存只存在一个对象。

想要保证对象唯一

一：饿汉式

1，为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。将构造函数私有化

2，为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。在类中创建一个本类对象

3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。提供一个方法可以获取到该对象

当需要将事物的对象保证在内存中唯一时，就将以上三步加上即可

这就是单例设计模式

二：懒汉式

对象是方法被调用时，才初始化，也叫做对象的延迟加载。称为懒汉式

饿汉式和懒汉式的区别

饿汉式加载方式 Single类一进入内存就已经创建好了对象。

延迟加载：Single类进内存，对象还没有存在，只有调用了getInstance方法时

才建立对象。但是一般开发都用饿汉式相对安全些

public class singledemo
{
provate static final singledemo onlyOne=new singledemo();
public static singledemo()
{
return onlyOne;
}
private singledemo(){}
}//这就是一个单例设计模式

主函数：

格式是固定的被Jvm锁识别和调用。

Public ：由于jvm需要调用类的main()方法那么该方法的权限必须是public

Static ：不需要对象的，直接用主函数所属类名调用即可。【嘿嘿也就是上面的静态】

Void：无返回值类型。

Main：main()这个是类中必须有的方法

String [] args:这是主函数的参数列表，是一个数组的形式。就是接收一个String类型的数组参数

public class maindemo
{
public static void main(String[] args)
{
for(int i=0;i<args.length;i++)
{
System.out.println(args[i]);
}//这里对待上面就是一个很好的证明
}
}

这就是上面程序解释

内部类：

在一个类的内部定义类这就叫嵌套类，也叫内部类。

类中定义的内部类：

在类中直接定义的内部类的使用范围，仅限于这具类的内部，也就是说A类里定义的一个B类那么B类只被A类知道不能被其他类知道它可以直接访问和引用它的的所有变量和方法，就像外问类中的其他非static成员的功能一样，

和外部类不同的是内部类可以声明为private或protected.

这里我们定义一个名为outerdemo的类定义一个实例变量outer-a，一个test（）方法和一个名为inner的内部类

class outerdemo
{
int outer-a=100;
void test()
{
Inner in=new inner();
in.display();
}
class Inner//这里定义了一个内部类是在outerdemo这个类的｛｝内定义的类可能 调用他的实例变量
{
void displasy()//就是用的这个方法直接调用的外部类的实例变量

{
System.out.println("display:outer-i="+outer-i);
}
}
class InnerClassDemo
{
public static void main(String[]args)
{
Outer outer=new Outer();
outer.test();
}
}//这就是一个内部类

内部类使用程序代码更紧凑，更加模块化。

结论：当一个类中的程序代码要用到另外一个类的实例对象而另一个类中的程序代码又要访问第一个类中的成员，将另外一个类作成第一个类的内部类。一个内部内可以访问内部类，但是与之相反内部类的成员只有在内部类中是可知的，并不能被外部类调用

关于static与内部类:

如果static修饰一个内部类，这个类就相当于一个特殊外部定义的类，所以static的内部类中可以声明static成员，但是非static的内部类中的成员是不能声明为static的，static的内部类不能再使用外层封装的非static的成员变量。

如果内部类的局部变量和成员变量和外部类的成员变量局部变量重命名那么我们如何来指定我们需要访问的变量呢？

下面是他的定义格式示例

public class staticdemo
{
private int size;
public class Inner
{
private inr size;
public void doStuff(int size)
{
size++;//引用的是dostuff函数形参
this.size++;引用的是Inner类中的成员变量
static.this.size++;//引用 的是static类中的成员变量
}
}
}