黑马程序眼_Java基础(2)面向对象(一)

------- android培训、java培训、期待与您交流！ ----------

(day05面向对象-******************************************************************************
(概念，类与对象的关系，封装，构造函数，this)
成员变量：作用于整个类中。在堆内存中，因对象存在而存在。垃圾回收机制进行回收。
局部变量：作用于整个函数中，或语句中。栈内存中。数据用完自动释放。
@@匿名对象：
 对对象方法仅进行一次调用时，
 匿名对象可以作为实际参数进行传递。
new Car().color="red";
new Car().num=3;
new Car().run();
@@封装Encapsulation：隐藏对象的属性和实现细节，仅对外提供公共访问方式；
      将不需要对外提供的内容都隐藏起来。
      把属性都隐藏，提供公共方法对其访问。
封装--方法，类，包，框架。
private:可以用于修饰类中的所有成员，私有只在本类中有效。构造函数可以被私有化！
一个成员变量通常对应两个成员方法，set和get
私有仅仅是封装的一种表现形式。
@@构造函数：给对象进行初始化
 函数名与类名相同**
 不可以定义返回值类型**
 不可以写return语句**
注意--1，默认构造函数 2，多个构造函数是以重载的形式存在。
      3，构造函数可以被私有化！私有化后无法创建！
对象一建立就会调用与之相对应的构造函数。
当类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数。
当类中定义了构造函数时，默认的构造函数就没有了。**
构造函数与一般函数写法上不同，运行上不同。
 构造函数在对象一建立时就运行，一个对象建立构造函数就运行一次。
 一般方法对象调用才执行，可以被调用多次。
当分析事物时，该事物存在就具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造代码块：(放在构造函数前或后，对象一建立就运行,都先于构造函数执行！**)
 {
  System.out.println("nimenhao");
 }
 作用：给所有对象进行统一初始化，对象一建立就运行，而且优先于构造函数执行。
构造函数是给对应的对象进行初始化。
构造代码块中定义的是不同对象共性的初始化内容。
@@this
局部变量和成员变量可能重名。函数优先选择局部变量，然后是类中的成员变量。
所以构造函数中this.name = name;
this代表它所在函数所属对象的引用！哪个对象在调用this所在的函数，this就代表哪个对象！
this.变量 表示的是this对象的成员变量。
(this.函数也可以)
this应用：
1，this关键字(带.)-->当定义类中函数时，该函数内部要用到 调用该函数的对象时，用this代表这个对象。
2，this语句(不带.)-->构造函数之间的调用只能用this语句！！！**
   --------this语句只能定义在构造函数的第一行(否则编译失败！)
 Person(String name,int age)
 {
  this(name);//调用Person(String name)构造函数。
  this.age = age;
 }
初始化的动作要先执行，初始化之中还有初始化，就先执行初始化之中的初始化。
(day06面向对象：static，单例设计模式)******************************************************************
@@static----用于修饰成员，不能修饰局部！
被static修饰后的静态成员的特点：
 随着类的加载而加载,随着类的消失而消失。说明它的生命周期最长。
  javac 文件名 的时候，文件中的类会编译生成。用到某类的时候，类会加载！
 优先于对象存在
 被所有对象共享
 可以直接被类名调用-->类名.static成员
注意：
 静态方法只能访问静态成员！
 静态方法中不可以写this，super关键字(因为静态方法先于对象存在。)
 主函数是静态的。
String name；成员变量也叫实例变量
static String country=CN;静态的成员变量也叫类变量。
利处：对对象的共享数据进行单独空间的存储，节省空间，可以直接被类名调用。
弊处：生命周期过长，访问出现局限性(静态虽好，只能访问静态)。
静态代码块:
static
{
 执行语句。
}
特点；随着类的加载而执行，只执行一次。并优先于主函数执行!用于对类进行初始化的。
@@主函数 public static void main(String[] args)
主函数是一个特殊的函数，作为程序的入口，可以被jvm调用。
public：代表着该函数的访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别，
(String[] args):函数的参数，参数类型是一个数组，数组中的元素是字符串。
 就是 java demo 函数的参数     //*******
唯一可以改的是args，也就是arguments(翻译-->参数)
jvm在调用主函数时，传入的参数是 new String[0];长度为0;参数地址-->[Ljava.lang.String;@1fb8ee3
用户可以自己java demo 1 2 3 //这样的话，参数就是1 2 3,长度是3.
一个类A的编译，如果A中用到了类B，那么会先在指定目录下找B.class文件，
 没有的话在指定目录下找同名的B.java文件，如果有，则先编译B.java文件。
工具类的方法一般是静态的，其构造函数是私有的。
API--application-program-interface
静态代码块：随着类的加载而执行，只执行一次。并优先于主函数执行!
static
{
 语句；
}
@@笔记2,构造函数，构造代码块，静态代码块，静态成员，主函数？---顺序？
(类的加载-->指的是new新的对象时，如果new的对象为空，则不加载类；
 demo d = null;时，demo没有被加载；new demo();demo被加载)
构造函数(被动)：随着对象的创建而执行。
 作用：给特点的类进行初始化。
构造代码块(被动)：对象一建立就执行,无论放在构造函数前或后，都先于构造函数执行！
 作用：给类的所有对象进行统一初始化。
静态代码块(被动)：随着类的加载而执行，只执行一次。并优先于主函数执行!
 所用：给类进行初始化。
主函数(被动)：程序入口。
静态成员(主动)：随着类的加载而加载,然后存在于方法区中,随着类的消失而消失。生命周期最长。静态函数被调用才执行。

对象的初始化过程？
Person p=new Person("wzq",22);做了哪些事情
1，因为new用到了Person.class，所以会先找到该文件，并将其加载到内存中。
2，执行该Person类中的static代码块，给Persion.class进行初始化
3，在堆内存中开辟空间，分配内存地址。(栈内存中为p开辟空间)
4，在堆内存中建立对象的特有属性(成员变量)，并进行默认初始化-->private int age=0；
5，对属性进行显式初始化-->private String name = ren；
6，对对象进行构造代码块初始化；
7，对对象进行对应的构造函数初始化-->"wzq",22 初始化对象name=wzq,age=22;
8，将堆内存地址赋给栈内存中的p变量
@@单例设计模式 -->解决一个类在内存中只存在一个对象。开发建议使用饿汉式。private static demo d = new demo();
(设计模式有23个)
第一种体现
  1将该类的构造函数私有化，使外部不能调用该类的构造函数，只能该类的内部调用其构造函数。
  2在该类的内部自定义一个对象。
  3对外提供方法进行该唯一对象的获取。
  class demo//类一进内存，就已经创建好了对象。
  {
 private demo(){}
 private static demo d = new demo();//先初始化对象--饿汉式；
 public static demo getDemo()
 {
  return d;
 }

  }
第二种体现：
  class demo//demo进内存，对象还没有存在，调用getDemo方法时，才创建对象。
  {
 private demo(){}
 private static demo d = null;//后初始化对象--懒汉式；
 public static demo getDemo()
 {
  if(d==null)
  synchronized(demo.class)
  {
   if(d==null)
    d = new demo();//对象是方法被调用时才初始化，也加对象的延时加载。
  }
  return d;
 }

  }
(day07)************************************************************************
@@继承 java只支持单继承，只能继承一个类。多继承容易带来安全隐患。
 1，提高了代码的复用性
 2，让类和类之间产生了关系，有了这个关系，才有了多态。
 查阅父类功能，创建子类对象使用功能。
子父类中变量的特点。
 Zi z = new Zi();//加载子类前，先加载父类文件。
1，变量:如果子类中出现了非私有的同名变量时，
 子类要访问本类中的变量，用this；
 子类要访问父类中的变量，用super；
super和this的用法几乎相同。super代表的是父类对象的引用。
2，函数：子类出现和父类一模一样的函数时，当子类调用该重名函数时，会调用子类的函数，如同父类的函数被覆盖一样。
 函数的新特性：覆盖(重写)-->子类和父类中的函数完全相同，子类函数覆盖父类函数。
 当子类继承了父类，沿袭了父类的功能到子类中，但是子类虽有该功能，但功能内容不一样可以使用覆盖特性，保留保留父类功能定义，重写功能内容。
@@覆盖  子类覆盖父类，必须保证子类函数权限大于等于父类函数权限，才可以覆盖，否则编译失败。
 父类函数被私有后，子类不知道父类有该函数，无法覆盖。
 静态只能覆盖静态，不能覆盖非静态。
函数重载：同一个类中，一个以上的同名函数，参数个数或者参数类型不同即可重载！与返回值类型无关！
函数重写：发生在子父类中，子父类方法要一模一样，包括返回值类型、参数。子类函数权限>=父类函数权限。父类该函数不能是私有的。
3，构造函数：-->子类构造函数一定会调用到父类的构造函数。
 (父类有空参数的构造函数)子类构造函数首行没有显式调用super(参数)或this(?)，那么所有子类构造函数首行默认隐式调用语句super();
 父类没有空参数的构造函数，子类构造函数第一行必须显式调用super(参数)或this(?)，因为默认的super(无参)会调用失败；
 结论：子类的所有构造函数默认都会访问父类中空参数的构造函数，因为子类每一个构造函数内第一行都有一句隐式super();
     当父类中没有空参数的构造函数时，子类必须手动通过super或者this来指定要访问父类中的构造函数。
@@final ：修饰 类 函数 变量(成员变量或局部变量)；目的是为了避免被重写！
final 类：不可以被继承-->避免被继承，避免被子类重写功能。
fianl 方法：不可以被重写。
final 变量：常量，只能被赋值一次。单词间通过_连接。
内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
@@抽象类abstract  修饰 类，方法。
有抽象方法的类就必须是抽象类，抽象类不可以实例化。强迫子类去实现抽象类中的抽象方法。
抽象类中可以不定义抽象方法，作用-->避免实例化。
abstract class demo
{
 abstract void show();
 ......
}
 1，抽象方法一定在抽象类中
 2，抽象方法和抽象类都必须被abstract修饰。
 3，抽象类不可以用new创建对象，因为调用抽象方法没意义。
 4，抽象类中的方法要被使用，必须由子类重写所有的抽象方法后，建立子类对象调用。
模板方法模式设计模式：
在定义功能时，功能的一部分是确定的，有一部分不确定，而确定的部分在使用不确定的部分，
那么这时将不确定的部分提供出去，有该类的子类实现完成。
abstract class GetTime
{
 public final void getTime()//不让重写
 {
  long start = System.currentTimeMillis();
  runCode();
  long end System.currentTimeMillis();
 }
 public abstract void runCode();//必须重写
}
@@接口： 内部全是抽象方法的抽象类！成员都是public
 1，接口中常见定义：修饰符固定！
  public static final 类型 常量;-->也可以写  类型 常量;
  public abstract void 抽象方法--> void 抽象方法。
 接口中自动给成员中补写：public static final 常量;
    public abstract  抽象函数;
 2，接口不能new，必须子类将其所有抽象类重写后，子类才能实例化。
 3，接口编译后也是class文件。
 4，接口可以多实现。class Demo1 extends Demo2 implements Demo3,Demo4
 5，接口之间可以继承。还可以多继承。interface A extends B,C

 ------- android培训、java培训、期待与您交流！ ----------