黑马程序员——java基础--面向对象（篇一）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

第一章

1、面向对象     2、成员变量      3、匿名对象     4、封装      5、构造函数        6、关键字this

第二章

1、关键字static    2、知识点总结     3、初始化过程    4、初识设计模式

第三章

1、继承    2、继承名言   3、其他关系   4、覆盖     5、this语句    6、关键字final           7、抽象

8、总结封装和继承    9、抽象引用   10、接口

代码附录

1、给主函数传参  2、初始化过程     3、单例设计   4、接口与继承的运用            5、模版设计

第一章

1，面向对象
面向对象是一种思想，生活方方面面都有体现，可以使执行者变成指挥者，把复杂的问题简单化，而不必去关心具体的过程。
三个特征：封装，继承，多态。后面细述。

2，成员变量
是全局的，存在于堆内存中，随对象而创建。

 3、 匿名对象
 由于没有引用，创建第二个时，第一个就会被垃圾回收，故调用属性没意思  。       

只在调用方法时使用，且只能调用一次。
                     凡简写的，都有缺陷。
                     匿名对象可以用来传递参数

                    引用类型有四种：强，弱，软，？。
4、封装
       隐藏对象的属性和实现细节，对外提供公共的访问方式。
       函数是最小的封装体，类也是封装。
       好处：将变化隔离，使用方便，提高代码复用性，提高安全性。
5、构造函数
      分析一类事物时，描述其所具有的特征，用到构造函数。
     构造代码块：先于构造函数执行，用于给所有对象初始化。
6、this
     代表 当前对象的引用。

      this语句：                                            
          （1）只能用于构造函数间。
          （2）必须写在构造函数第一句：初始化会先执行，且只执行一次。
          （3）this语句中的this其实代表的还是当前对象的引用。

第二章

1．关键字static

被static修饰的成员（成员变量 和 成员 函数），可以为所有对象共有。多了一种调用方式。存在于方法区/共享区/数据区 中。
A.特点：
（1）岁类的加载而加载：说明生命周期很长
（2）为所有对象共用
（3）先于对象存在
（4）直接被类名调用

B.对象特有：成员变量—实例变量                       对象共有： 静态的成员变量—类变量

利：（1）共享   节省内存;
         （ 2）可以用类名访问。

弊：（1）生命周期过长；
         （2）访问有局限性（只能访问静态）。
C.什么时候用到静态？
（1）有共享数据时，定义 静态的成员变量
（2）没有使用到   对象特有 数据时，定义静态方法

D.总结AarrayTool编写
工具类的编写，函数静态化
内部函数私有化，没必要暴露
无参构造函数私有化，确保严谨，只被类名调用

2、知识点总结

类什么时候加载？
：在使用到类的内容时才加载

什么是静态代码块？
：静态代码块在类加载时，运行；
    用于给类初始化。
    执行顺序为：类加载时执行静态代码块，类加载完后调用main函数。

静态代码块与构造代码块的区别？
：静态代码块  用于给类初始化，构造代码块用于给所有对象初始化。

3、初始化过程

.Person p=new Person(“zz”,23),这句话做了什么？
（1）加载类；
（2）运行静态代码块，给类初始化；
（3）在堆内存，分配空间，加载对象特有的属性，并默认初始化；
（4）显示初始化；
（5）运行构造代码块初始化；
（6）构造函数初始化；
（7）在堆内存，生成对象地址；
（8）在栈内存，创建变量p,并赋给地址。

4、初识设计模式
所谓设计模式，就是解决某一问题行之有效的方法。java中有23种 通用的设计模式。

单例设计模式

只创建一个对象为所有类调用。
饿汉模式：直接创建对象，安全，开发中常用
懒汉模式：调用方法时创建对象，有风险，解决方案是加同步锁，两次判断

第三章

1．继承

通过extends关键字，使得类与类之间有了血缘关系，并不断发展形成一个大的体系。
作用：
a.提高代码复用性
b.描述了类与类之间的一种关系

关系：万物皆对象，java是面向对象的，而事物是普遍联系的，继承是这普遍联系中的一 种，所以请善用！不能为了使用功能、简写代码而继承！继承是事物本身具有的关系，是与生俱来的。
2，继承名言
                     *  查阅父类功能，创建子类对象。

      *因为继承，所以多态。

3，其他关系
聚集：has a
聚合：become
组合：one part of

4．覆盖
含义：改写父类的方法
前提：子类函数权限 大于等于 父类函数权限
覆盖与重载的区别：

重载和重写都函数的特性

重载：同一类中，同名函数的参数列表不同
重写：子父类中，同名函数一摸一样

5，this语句
this()或者super(),都调用的对应构造函数，实质他们指代的还是当前对象的应用

初始化〉〉〉实例化
初始化和实例化是什么关系？

子类的初始化过程：
当父类的空构造函数存在时，每个构造函数都有一个隐身的super()语句；
当父类的空构造函数不存在时，必须手动指定带参的super(..)语句；
子类中至少有一个构造函数会访问父类的构造函数。
当然，也可以指定this()语句。

6，final
修饰类，该类不能被继承；
修饰函数，函数不能复写；
修饰变量，变量为定值。
常量，publicstatic final  XXXX=YYY;
目前为止，修饰class的有：public  和final。

7，抽象

抽象，即为 看不懂，不确定
抽象方法存在于抽象类中，抽象类不能实例化，需要子类继承并复写所有抽象方法..
复写部分抽象方法的子类仍是一个抽象类。这种情况貌似没必要存在？
抽象类特点：
a.比一般类多了抽象函数
b.不能实例化
特殊情况：
〉〉抽象类没有抽象方法

总结：抽象类有没有抽象方法都行，但抽象方法必须放在抽象类中

那麽，什么时候用到抽象方法？
：当功能主体不确定的时候

8．对封装和继承的总结
封装：
隐藏属性和实现细节，使用由复杂变简单，实现权限管理
继承：
是一个动作，通过它创建一种  与生俱来的  关系

9．抽象引用
抽象类的引用目前看来有三种方式：
a.全为抽象方法
b.部分为抽象方法
c.没有抽象方法
模版设计思想：
             当功能中有不确定的内容，暴露出去，让子类来完成。
抽象类需要通过子类来实例化。

10，接口

初期理解:当抽象类中的方法全部为抽象方法，该类就是一个接口
接口中的成员有固定的修饰符，成员：常量和抽象方法，成员全部为public

接口间可以多继承
特点：
a.接口是对外暴露的规则
b.接口是程序功能的扩展
c.接口可以多实现
d.降低了耦合性

类定义基本功能，接口定义扩展功能（体系外）

 

代码附录

1，给主函数传参

/*public static void main(String[] args) 主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。主函数的定义：public：代表着该函数访问权限是最大的。static：代表主函数随着类的加载就已经存在了。void：主函数没有具体的返回值。main：不是关键字，但是是一个特殊的单词，可以被jvm识别。（String[] arr）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。主函数是固定格式的：jvm识别。jvm在调用主函数时，传入的是new String[0];*/class MainDemo {public static void main(String[] args)//new String[]{String[] arr = {"hah","hhe","heihei","xixi","hiahia"};MainTest.main(arr);}}//String[] args = new String[3];//String[] args = null;class MainTest{public static void main(String[] args){for(int x=0; x<args.length; x++)System.out.println(args[x]);}}

2，初始化过程

class Person{private Person(){}private String name = "hah";private int age;private static  String country = "cn";Person(String name,int age){this.name = name;this.age = age;}{System.out.println(name+".."+age);}public void setName(String name){this.name = name;}public void speak(){System.out.println(this.name+"..."+this.age);}public static void  showCountry(){System.out.println("country="+Person.country);Person.method();}public static void method(){System.out.println("method run");}}class  PersonDemo{public static void main(String[] args) {Person p = new Person("zhangsan",20);p.setName("lisi");new Person();}}/*Person p = new Person("zhangsan",20);该句话都做了什么事情？1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。3，在堆内存中开辟空间，分配内存地址。4，在堆内存中建立对象的特有属性。并进行默认初始化。5，对属性进行显示初始化。6，对对象进行构造代码块初始化。7，对对象进行对应的构造函数初始化。8，将内存地址付给栈内存中的p变量。*/

3，单例设计

class Single{/*单例设计三步*/private  Single(){}private static Single s = new Single();public static  Single getInstance(){return s;}}<strong></strong>

4，接口与继承的运用

interface Inter{public static final int NUM = 3;public abstract void show();}interface InterA{public abstract void show();}class Demo{public void function(){}}class Test extends Demo implements Inter,InterA{public void show(){}}interface A{void methodA();}interface B //extends A{void methodB();}interface C extends B,A{void methodC();}class D implements C{public void methodA(){}public void methodC(){}public void methodB(){}}

5，模版设计：有抽象相关的设计模式

/*需求：获取一段程序运行的时间。原理：获取程序开始和结束的时间并相减即可。获取时间：System.currentTimeMillis();当代码完成优化后，就可以解决这类问题。这种方式，模版方法设计模式。什么是模版方法呢？在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。*/abstract class GetTime{public final void getTime(){long start = System.currentTimeMillis();runcode();long end = System.currentTimeMillis();System.out.println("毫秒："+(end-start));}public abstract void runcode();}class SubTime extends GetTime{public void runcode(){for(int x=0; x<4000; x++){System.out.print(x);}}}class  TemplateDemo{public static void main(String[] args) {//GetTime gt = new GetTime();SubTime gt = new SubTime();gt.getTime();}}

错漏之处，欢迎指正！

 

 

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------