黑马程序员 一步一步往上爬 学习毕老师java视频的第05,06天

 

---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------

毕向东 Java基础视频教程05天 0102面向对象（概述）

１.   C是面向过程(功能)的，JAVA是面向对象的，由执行者转换成指挥者

２.   面向对象是基于面向过程的，只不过是把原来的功能封装起来放到对象里。

３.   怎么理解面向对象的：

把复杂东西变简单，

由执行者转换成指挥者

结合当前的实际场景结合连拍马屁

一切皆对象

    4.写程序时不是先定义功能，而是现面向对象，对象里面需要什么功能就把这功能写进去，下回需要这个功能时就去找该对象。有对象直接拿过来用，没对象就自己造一个对象。

 

 

 

 

 

 

毕向东 Java基础视频教程05天 03面向对象（类与对象的关系）

１.   类是一个抽象的概念，是你要创建的对象实体的一个模板，是对你要创建的实体对象的描述；定义类就是在定义对象实体的属性和行为，属性和行为共同成为类中的成员。（成员变量和成员方法/函数）

２.   OOP:object oriented programming

３.   面象对象程序设计的基本特征：将现实世界的特性和行为进行封装，形成抽象的类，通过类去创建实体对象，既然封装就以为者隐蔽性，用户直接调用对象提供的方法接口，而不用理会具体如何实现。

4，属性保存在变量中，行为通过方法去实现。

 

 

 

 

 

毕向东 Java基础视频教程05天 04面向对象（成员变量和局部变量）

１.   当类需要独立运行时，就写main函数，当类不需要独立运行时就不写main函数。

２.   成员变量作用于整个类中，局部变量作用于函数或者语句中，成员变量因为对象的存在才在堆内存中存在。局部变量在栈内存中。只有对象产生之后才有color number

 

 

 

毕向东 Java基础视频教程05天 05面向对象（匿名对象的应用）

１.   匿名对象只能调用一次方法：

new Car（）.run();

再次用new Car().run();之前的对象消失，又建立一个新的对象

而且匿名对象修改属性没有意义。

２.   匿名对象可以作为实际参数进行传递

 

 

 

 

 

 

毕向东 Java基础视频教程05天 06 07面向对象（封装，private）

１.   封装：隐藏对象的属性和实现细节（方法），仅对外提供公共访问方式

２.   函数就是JAVA代码中最小的封装体

３.   权限修饰符：public private

４.   类和对象都具有封装性

５.   一个成员变量对应两个访问方式：set get

６.    对变量的set操作：

将类中的成员变量私有化之后，类以外建立的对象也不能直接访问。要想访问就在要在类中去建立访问方式---函数

private int age;

public void/int set/getAge(int a)

{

            age=a;

 

}

 

对变量的Get操作:

public int getAge()

   {

            return age;

   }

 7．私有只是封装的一种表现形式，只要不在访问权限中，都是封装。

8.之所以提供对外访问方式，只因为可以再访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码的健壮性。

9.将类中属性都隐藏，对外提供公共访问方式。

10.成员变量在堆内存中有默认初始化值

 

 

 

 

 

毕向东 Java基础视频教程05天 08面向对象（构造函数）

１.   对象一建立就会调用与之对应的构造函数

２.   构造函数作用:对对象进行初始化，这样对象才创建成功，当我们没有在类中创建构造函数时，系统会自动在类中加上一个空参数构造函数person(){}

３.   New完之后就会找对应的初始化函数

４.   构造函数和一般函数不仅在写法上不同，运行也不同，构造函数是在对象已建立就调用，对对象进行初始化，一般函数只对对象增加功能。

５.   什么时候定义构造函数，在分析事物时，事物就已经具备了一些特性和行为，就把这些内容定义在构造函数里。

 

 

 

毕向东 Java基础视频教程05天 09面向对象（构造代码块）

1，  构造代码块优先于构造函数对所有的对象进行初始化，然后在进入对应的构造函数，作用在于对所有的对象在初始化的时候进行共性的操作。而构造函数仅仅初始化对应的对象。

 

 

 

 

毕向东 Java基础视频教程05天10面向对象（this关键字）

1.如果把类中的所有构造函数private，那么主函数里建立的对象就都不能初始化，也就建立不了对象了。

2.在类中构造函数时，如果参数名和成员变量名相同，那么在构造函数中的同名变量都视为局部变量（参数变量）如

Class Person

{

         private String name;

         private  int age;

Person(String name)

{

         Name=name;   这时person(String)构造函数中的name都是局部变量/形参，不是成员变量。也就是说参数name接收到的实参没有传给对象中对应的成员变量，而是传给了形参自己。

}

2，  哪个对象在调用函数，该函数中的this就代表这个对象。

把局部变量name赋给对象中的name，就用this代表对象。

３.   类中成员都是被对象所调用的，so类中的函数都是要对象去调用的。

 

 

 

 

 

毕向东 Java基础视频教程05天11面向对象（this关键字的应用）

１.   想要知道this代表哪个对象，就看哪个对象调用了这个方法/函数

２.   对两个对象的属性进行比较：用一个对象调用类中的创建的比较方法进行两个对象的属性的比较时，把另一个对象作为实际参数传给方法中的形参，然后用this.age==形参名字.age，最后将结果返回给对象1.compare(对象2)

３.   对于如果比较 return 真，否则return false的情况，都直接简化为

Return  A比较符B；                        

４.   在给文件起名字的时候通常命名为拥有main函数的类的名字，保证java文件名和编译之后产生的可以独立运行的类的名字一致。JVM运行拥有含有main函数的可以独立运行的类。

 

 

 

 

毕向东 Java基础视频教程05天12面向对象（this关键字在构造函数间应用）

１.   构造函数间调用只能用this语句，如在初始化（姓名，年龄）时，既有一个初始化姓名的构造函数，又有一个初始化姓名又初始化年龄的构造函数，那么早第二个构造函数中，初始化姓名就直接调用第一个构造函数，不过这是不是写Person（name），而是用this(第二个构造函数的形参name). 所以碰到this(),就可以把this看成类名。

２.   构造函数之间的调用谁调用谁可以通过把this转成类名，通过参数类型和个数判断。

３.   This()语句必须放到构造函数的第一行

问题：this()为什么必须放在构造函数的第一行 因为初始化要先执行。

 

 

 

 

 

毕向东 Java基础视频教程06天01面向对象（static关键字）

１.   static修饰的内容单独提取出来被对象所共享，代码没有区别，但是节省内存空间，没必要在每个对象里都创建。Static只能用于修饰成员，不能修饰局部变量。

２.   成员变量用static两好处，节省空间，可以通过类名调用成员。

３.   成员方法用static：可以被类名调用

４.   Static所修饰的内容被提取出来放在共享区，方法区，数据区

５.   Static会随着类的加载而加载，随着类的消失而消失

６.   非static变量是实例（实体）变量，static变量是静态成员变量，也叫类变量。

７.   不建议定义过多的静态变量：因为静态变量的生命周期长，当对象不存在时它，存在，当对象小时后，它还在，消耗内存。So数据被多个对象所共有就静态，or不静态。

８.   无论是静态变量还是静态方法都可以直接被类名调用

９.   静态方法只能访问静态成员（方法+变量）   静态虽好只能访问静态

１０.            静态先出现（出现的时候就只有自己），非静态后出现（静态和非静态都已存在），所以静态方法只能访问静态的变量和方法，非静态方法既可以访问静态变量，也可以访问非静态变量。

10.静态方法中不可以出现this super关键字，因为静态先被加载，此时对象还不存在，this无所指。

11.主函数是静态的

 

 

 

毕向东 Java基础视频教程06天02面向对象（main函数）

１.   主函数中，public表示访问权限是最大的，因为他要被jvm访问

２.   Static表示main随着类的加载而加载。

３.   Void没有具体的返回值，jvm调用main,只要把main的程序运行就行了。主函数值被虚拟机调用

４.   jvm主函数的字符串数组中传入的可以理解为三个方面，

new String[0];

字符串数组的地址变量

数组（个人理解用）

５.   执行java命令时，自动启动虚拟机，虚拟机开始执行我们传给的类，并调用主函数，在调用时我们传给虚拟机一些参数haha  hehe  heihei  那么main的字符串数组就把这些都接收到自己的数组中去了。

６.   类名可以调用静态方法，再给主函数的形参传递实参的时候，我们就把形参当做一个字符串数组，然后给他传递一个字符串数组，以方便理解。

７.   主函数既可以被虚拟机调用，也可以被类名调用。所以在给主函数传参数时，既可以通过jvm调用时传参数，也可以用类名调用主函数然后传给他一个字符串数组。

注意：在用类名调用主函数并传给它一个字符串数组时，需要在前一个也含有主函数的类中去进行，这样一个java程序中含有两个都含有主函数的类。而不能在自己的主函数内通过类名去调用本主函数传递数组。Jvm在运行时先从第一个含有主函数的类开始运行。

８.   编译的时候编译的是我们保存的java文件，运行时运行的是含有main函数的类

 

 

 

 

 

 

毕向东 Java基础视频教程06天03面向对象（静态什么时候使用）

１.   什么时候定义静态变量：当对象中出现共享数据时

２.   什么时候定义静态方法：当只访问到静态变量和静态方法时，当功能内部没有访问到非静态变量name，或者叫对象特有变量name。

 

 

毕向东 Java基础视频教程06天04面向对象（静态的应用-工具类）

１.   要通过类去建立对象必须先通过编译产生出该class文件

２.   类中能私有的都把它私有，只给外界暴露你所需要的东西就行了。

３.   对象是用于封装数据的，但是如果发现对象创建之后并没有对象特有数据，仅仅调用方法，而方法都被共享了，那么对象的创建就没有什么意义。

４.   对象中没有对象特有数据，而方法中也没有对象特有数据，那么就把方法static,直接通过类名来调用。为了防止其他人产生没有意义的对象，再将构造函数private化。

５.   记住在for(y=;y<;y++)控制比较次数时，比较次数是由y的前后两个边界决定的，不是只看第二个y<多少决定的，除非y=0

 

 

毕向东 Java基础视频教程06天05面向对象（帮助文档的制作-javadoc）

1.  为了更快的找到我们想要的可执行文件（exe可执行文件+java可执行文件/类文件），进行环境变量配置，如果我们想要运行的是exe可执行文件，就将其存放路径设置在path环境变量下，如果想运行的是class文件，就把文件路径设置在classpath环境变量中。

2. 什么时候会用到classpath，第一计算机在寻找class文件时会自动到classpath中去找，第二个计算机在运行class文件时。同样计算机在寻找和运行exe可执行文件时，现在当前文件下找，找不到就到path路径下找。

3.想形成说明文档，说明你想暴露，想暴露就要权限够大，加个public

4.类的默认的空参数构造函数的权限和类一致

5.在自己的java文件中注释有作者和和版本，但是在传给别人类文件和帮助文件时，不想传给别人姓名和版本时，就可以在java doc –d myclass 后面不写-author –version ArrayTool.java

6.对类进行分别存储就叫包

 

 

 

毕向东 Java基础视频教程06天06面向对象（静态代码块）

１.   构造代码块优先于构造函数对所有的对象进行初始化，静态代码块随着类的加载而运行，只执行一次，对类进行初始化，并优先于主函数运行。

２.   只有类中的东西被用了，类才会加载到内存中区，加载一次就不需要在加载了。

３.   在dos命令行一执行java StaticCodeDemo 这个类就被加载如内存中，一旦这个类被加载，其中的static代码块就被执行，在StaticCodeDemo主函数中，我们new StaticCode() 就会到类StaticCode中去调用默认构造函数，因为要用到类StaticCode中的类容，该类就自然被加载到类存中去，一加载就执行static代码块，再new StaticCode（）,还是去寻

找默认构造函数，但是由于类StaticCode已经被加载，所以static代码块就不会再执行。

StaticCode.show().通过类名去调用静态方法，因为要调用show()即必须把类StaticCode加载到内存中，static代码块就被执行一次。StaticCode   s=NULL，s不指向任何内容，也没有建立任何对象，类不被使用，所以类就不被加载。

４.   静态代码块和静态方法中是不能出现非静态变量的，而代码块中是可以的，因为代码块就是给对象初始化的，这是代码块中的非静态变量就已有所属了。

 

 

 

 

毕向东 Java基础视频教程06天07面向对象（对象的初始化过程）

１.   堆内存中的变量一出现就有默认初始化值，然后再到构造代码块进行初始化

２.   构造函数对对象进行初始化之后对象才真正建立成功。

３.   Person p=new Person(“zhangsan”,20);

过程分析：

因为要new一个person,所以先要把person的类文件加载进内存

   类一加载，就要运行静态代码块，如果有的话，对类进行初始化

   开始在堆内存中开辟对象空间，并分配内存地址

   在堆内存中建立对象特有属性，并进行默认初始化

   对对象属性进行显示初始化

   通过构造代码块对对象进行初始化

   通过构造函数对对象进行初始化 对象建立成功

   将地址值赋给栈内存中的p

 

 

毕向东 Java基础视频教程06天08面向对象（对象调用成员过程）

１.   调用类中的成员时，要么是对象调用，要么是类名调用，一般省略对象名和函数名

２.   谁调用方法，方法中的this的值就是谁的值，或者就可以说this就是谁

３.   静态随着类的加载而加载

 

 

 

 

 

 

 

问题：函数有函数的类的属性是什么

         主函数调用自定义函数，是通过什么调用的

       类中非静态方法是什么时候加载到方法区的

 

 

毕向东 Java基础视频教程06天09面向对象（单例设计模式）

１.   GOF 设计模式，23种通用模式。不是偏代码，而是片思想，总结的经验规律，把几种模式综合应用一下就形成一个复杂的模式，称之为框架。

２.   单例设计模式：一个类在内存中只有一个对象

３.   要保证对象的唯一性：

a.       禁止其他程序建立该类对象，private 默认构造函数

b.       要建立一个该类对象，在该类中自定义一个对象

c.       为了让其他程序访问到该类对象，通过建立一个方法提供访问方式

事例：

class Student

{

private int age;

private Student(){}

private static Student s=new Student();

public static Student getinstance()

{

           return s;

}

public void setAge(int age)

{

           this.age=age;

}

public int getAge()

{

           return age;

}

}

class PersonDemo

{

public static void main(String[] args)

{

           Student s1=Student.getinstance();

           Student s2=Student.getinstance();

           s1.setAge(23);

           int m=s2.getAge();

           System.out.println(m);

}

}

４.   方法能够被其他程序访问到那就public

５.   调用方法时必须在后面加（）

 

 

 

 

毕向东 Java基础视频教程06天10面向对象（单例设计模式二）

１.   单例设计模式：饿汉式  懒汉式

２.   饿汉式：类一加载到内存中 对象就在堆内存中建立并初始化

Class Single

{

         Private Single(){}

         Private static Single s=new Single();

         Public static Single getInstance()

{

         Return s;

}

}

３.   懒汉式：类加载到内存中时，对象并没有在堆内存中建立并初始化，而是在调用getinstance时才加载到对内存中初始化。也叫做对象延迟加载

Class Single

(

Private Single(){}

Private static Single s=null;

Public static Single getInstance()

{

If(s==null)

   s=new Single();//创建s对象

return s;

}

)

４.   懒汉式和饿汉式区别就在于对象有没有随着类的加载而加载。开发一般用饿汉式，创建单例设计模式,因为cpu处理时是在不同程序间切换的，懒汉式容易出现安全隐患，创建多个对象。

５.   Public static Single getInstance()

{

If(s==null)

６.   →A程序执行到此 cpu切到 B程序，B程序进来执行到此，又切到A，创建对象，又切到B，b也创建了一个对象，so Public static synchronized Single getInstance()，synchronized同步，给方法上锁，一次只能进去一次程序，但是这样一来程序想进来就要判断，降低效率。

７.   既解决懒汉式的安全隐患，又不降低效率的方法：

Public static Single getInstance()

{

 If(s==null)

{

           Synchronized(Single.class)

           {

                    If(s==null)

             →A停在这，B进入了if但是被所挡在外面，待A创建完对象后出来，B就进来了，这是s已经有值了，就不再创建对象了。而当C再进来时，s！null,直接return s。这样一来安全性保证了，锁也只对两个程序进行了判断。

                             S=new Single();

}

     Return s;

     }

}

 ---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------

详细请查看：<a href="http://edu.csdn.net/heima" target="blank">http://edu.csdn.net/heima</a>