面向对象II

代码块：

就是通过一对大括号括起来的部分

局部代码块:

     在方法中使用的代码块就是局部代码块

作用：

可以控制变量的使用范围

构造代码块:

       在类中使用的代码块就是构造代码块

作用：

可以给成员变量赋值,在构造方法前执行

 

代码体现：

class Person {

     Stringname;

     intage;

          //构造代码块

     {

                         System.out.println(name + "***" + age);

     }

 

 

     publicPerson(){

 

          System.out.println(name+ "***" + age);

          name= "大龙猫";

          age= 3;

     }

 

     {

          name= "加菲猫";

          age= 15;

     }

 

     publicvoid method () {

          System.out.println(name+ "***" + age);

     }

 

}

 

class CodeBlockDemo {

     publicstatic void main(String[] args) {

                    //创建对象

          Personp = new Person();

          p.method();

 

     }

}

 

//程序执行的结果依次为：

//null***0

//加菲猫***15

//大龙猫 *** 3 

 

 

static关键字的由来（结合以下代码分析）：

当前定义的对象都是中国的

每次给对象赋值， country--> "中国"，占用了4个字节

那么，如果我们有100个对象，那就占用了400个字节。

而我们发现，国家是一样的，这个成员变量重复了，

能否让它不重复呢？能，java中提供了一个关键字，static

作用是：把所有对象共享的属性定义为静态。

 

通过观察下列代码的结果发现：

非静态的成员变量修改，只对当前对象有效；

而静态的成员变量修改，对所有的对象有效；

所以，可以将所有对象共享的属性定义为静态的。

 

代码体现：

class Person {

     Stringname;

     intage = 30;

     staticString country = "中国";

 

     publicPerson(){}

 

     publicPerson(String name) {

          this.name= name;

     }

 

     publicPerson (String name, int age, String country) {

          this.name= name;

          this.age= age;

          this.country= country;

     }

}

 

class StaticDemo {

     publicstatic void main(String[] args) {

          Personp = new Person("成龙",60,"中国");

          System.out.println(p.name+ "***" + p.age + "***" + p.country);

          Personp2 = new Person("李连杰", 52, "中国");

          System.out.println(p2.name+ "***" + p2.age + "***" + p2.country);

 

          Personp3 = new Person("成龙");

          p3.age= 58;

          p3.country= "美国";

          System.out.println(p3.name+ "***" + p3.age + "***" + p3.country);

 

          Personp4 = new Person("房祖名");

          System.out.println(p4.name+ "***" + p4.age + "***" + p4.country);

     }

}

 

静态成员与普通成员的区别：

1、什么时候存在和消失

     静态成员：静态的随着class的加载而存在，

                       随着class的消失而消失。生命周期长

     普通成员：普通的随着对象的创建而存在,

                      随着对象的消失而消失。

2、存储位置

     静态成员：存放在方法区中

     普通成员；存放在堆中

3、调用不一样

     普通成员：对象.成员

     静态成员：类名.成员或者 对象.成员

     

静态成员与普通成员理解上的区别

静态成员：是所有对象共享同一个变量。

                它是与类相关，类变量

普通成员：变量是每个对象单独拥有的。

                它是与对象相关，实例变量、成员变量

 

 在访问的时候：

          普通成员方法：

                 可以访问普通成员变量、成员方法

                 也可以访问静态成员变量、静态成员方法

          静态成员方法：

                只能方法静态成员变量、静态成员方法

 

          请记住：静态只能访问静态

 

代码体现：

class Demo {

     intnum = 10;

     staticint num2 = 20;

 

     publicvoid show () {

 

 

             //System.out.println(num); 

            //System.out.println(num2);

 

 

          show2();

          method2();

     }

 

     publicvoid show2(){

          System.out.println("haha");

     }

 

     publicstatic void method () {

            //错误:无法从静态上下文中引用非静态变量 num

          //System.out.println(num);

          //System.out.println(num2);

           //错误:无法从静态上下文中引用非静态方法 show2()

          //show2();

          method2();

     }

 

     publicstatic void method2(){

          System.out.println("hehe");

     }

}

 

 

 

class StaticDemo2 {

     publicstatic void main(String[] args) {

          

          Demod = new Demo();

          //System.out.println(d.num);

 

          //System.out.println(d.num2);

          //System.out.println(Demo.num2);

 

          d.show();

          d.method();

          

     }

}

 

数组操作工具类：

使用 ArrayTools.java文件中的方法

     注意：其实我们这里使用的不是ArrayTools.java文件，

               而是 ArrayTools.class文件，调用的是class文件中方法

 

          publicstatic void printArray(int[] arr){..}

          publicstatic int getMax(int[] arr){...}

          publicstatic void selectSort(int[] arr) {...}

          publicstatic void swap(int[] arr, int x, int y) {...}

 

     那么，我把数组工具类 ArrayTools.class 给你，你会用吗？

                将ArrayTools.class文件，与自己编写的java文件代码存放在同一个目录下调用。

代码体现：

class ArrayToolsDemo {

     publicstatic void main(String[] args){

          

          int[]arr = new int[]{1,3,9,6,7};

 

 

 

          //publicvoid printArray(int[] arr){..}

          ArrayTools.printArray(arr);

 

            //获得数组中最大值

          //publicstatic int getMax(int[] arr){

          intmax = ArrayTools.getMax(arr);

          System.out.println("max="+ max);

 

          //排序

          //publicstatic void selectSort(int[] arr) {...}

          ArrayTools.selectSort(arr);

 

          //遍历数组

          //publicstatic void printArray(int[] arr){..}

          ArrayTools.printArray(arr);

 

     }

     

     

}

 

帮组文档：也称API

API：（全称Application Programming Interface）

javadoc -d doc -author -versionArrayTools.java

javadoc 生成帮助文档的命令

-d doc  指定生成文档的目录存放在当前目录下的doc目录 

-author 包含 @author段

-version包含 @version段        

ArrayTools.java指定哪个java文件生成文档

 

main方法解析：

public: JVM调用main方法，所以，要求权限够大， 而public是最大的访问权限

static:方便JVM调用main方法，不需要创建对象

void:JVM调用的main方法，它拿到返回值没有意义

String[] args:字符串数组

 

 

Math工具类的使用：

abs:返回 值的绝对值

ceil:返回该值大于等于参数，并等于某个整数。

floor:返回该值小于等于参数，并等于某个整数。

max:返回两个 int 值中较大的一个。

min:返回两个 int 值中较小的一个。

pow:返回第一个参数的第二个参数次幂的值

random:返回带正号的 double 值，0.0<= x <1.0

round:四舍五入

sqrt:返回正确舍入的 double 值的正平方根

 

设计模式的分类：

总体来说设计模式分为三大类：

创建型模式，共五种：

     工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：

     适配器模式、装饰器模式、代理模式、外观模式、桥接模式、

     组合模式、享元模式。

行为型模式，共十一种：

     策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、

     命令模式、备忘录模式、状态模式、访问者模式、中介者模式、

     解释器模式。

 

其实还有两类：并发型模式和线程池模式

 

单例模式（Singleton）：

我们如何保证类在内存中只有一个对象呢?

     1:为了控制该类对象的建立,不让其他的类创建该类的对象.

     2:在本类中应该提供一个本类对象.

     3:提供公共的方式供别人访问这个对象.

 

代码如何实现呢？

     1、构造函数私有化，防止其他类创建该类对象

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

     3、提供一个public方法，对外访问

具体实现：

//饿汉式

class Student {

     //构造函数私有化，防止其他类创建该类对象

     privateStudent(){ }

 

     //在本类中，通过new关键字创建一个对象

     privatestatic Student stu = new Student();

 

     //提供一个public方法，对外访问

     publicstatic Student getInstance() {

          returnstu;

     }

 

}

 

class SingletonDemo {

     publicstatic void main(String[] args) {

          

          Students1 = Student.getInstance();

           Student s2 = Student.getInstance();

          Students3 = Student.getInstance();

 

          System.out.println(s1== s2 );

          System.out.println(s1== s2 );

     }

}

 

两种单例设计模式的区别？

     饿汉式：对象随着类的加载而创建

    懒汉式：需要使用的时候，再创造对象，以后使用的是同一个对象。

 

使用场合:

     工作的时候：饿汉式

     面试的时候：懒汉式

     原因：懒汉式，会出现线程安全问题

 

//懒汉式

class Student {

     

     //防止其他类创建本类对象

     privateStudent(){ }

 

     //在类中创建一个本类对象

     //privatestatic Student stu = new Student();

     //不想类文件，加载到内存中立刻创建对象

     //想调用获取对象的方法的使用，再创建对象

     privatestatic Student stu = null;

 

     //对外提供公共访问方法

     publicstatic Student getInstance() {

          if(stu == null) {

                stu= new Student();

          }

          returnstu;

     }

}

 

class SingletonDemo2 {

     publicstatic void main(String[] args) {

          

          Students1 = Student.getInstance();

          Students2 = Student.getInstance();

 

          System.out.println(s1==s2);

     }

}