传智播客-Java面向对象-day03

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

课程 名称  格式   什么时候执行  给谁初始化
0508 构造函数 函数名()  对象一建立就会调用与 给对应对象初始化
      之对应的构造函数
0509 构造代码块 {执行语句}  对象一建立就运行，而 给对象初始化
      且优先于构造函数执行。
0606 静态代码块 static{执行语句} 随着类的加载而执行， 给类初始化
      只执行一次。
*******执行构造代码块与成员变量显示初始化******
**********（代码中谁在前面谁就先执行）*********

类是继承，java只有单继承
接口是实现，java可以多实现，即可以实现多个接口(接口可以多继承)

成员变量和局部变量作用范围
成员变量作用范围：成员变量作用于整个类中。
局部变量作用范围：作用于函数中，或者语句中。

在内存中的位置：
成员变量：在堆内存中，因为对象的存在才在内存中存在。
局部变量：存在栈内存中。

这两句:
Car c=new Car();
c.num=5;
写成匿名对象：
new Car().num=5;
匿名对象调用属性无意义，调用方法有意义。

匿名对象使用方式一：当对对象的方法只调用一次，可以用匿名对象来完成，这样写比较简化。
如果对一个对象进行多个成员调用，必须给这个对象起个名字。

匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。
用java操作缓存时才设计到强引用，弱引用，虚引用

注意：私有仅仅是封装的一种表现形式。

成员变量都有默认值，在堆中
局部变量必须初始化，不初始化不能用，在栈中

构造函数写法特点：1.函数名与类名相同，2.不用定义返回值类型，3.不可以写return语句。
例：
class Person
{
 Person()
 {
  构造函数执行语句;
 }
}
作用：对象进行初始化。
注意：默认构造函数的特点，多个构造函数是以重载的形式存在的。
1、构造函数要与类同名(void是返回值不确定，构造函数是不需要返回值)
2、对象一建立就会调用与之对应的构造函数。
3、构造函数的作用：可以用于给对象进行初始化。
4、当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数
5、当在类中自定义了构造函数后，构造函数就没有了。
6、构造函数与一般函数的不同：
构造函数和一般函数在写法上有不同；
 1.在运行上也不不同；
 2.构造函数是在对象一建立就运行，给对象初始化；
 3.而一般方法是对象调用才执行，是给对象添加具备的功能。
 4.一个对象建立，构造函数只运行一次。
 5.而一般方法可以被该对象调用多次。

例：
class person
{
 person()  //构造函数
 {System.out.println("*");}
}
class persondemo
{
 public static void main(String[] args)
 {
 person p=new person();
 }
}

构造代码块写法:
{
 构造代码块执行语句；
}
构造代码块作用：给对象进行初始化。
对象一建立就运行，而且优先于构造函数执行。
构造代码块和构造函数的区别：
 构造代码块是给所有对象进行统一初始化；
 而构造函数是给对应的对象初始化。
 构造代码块中定义的是不同对象共性的内容。

this：看上去是用于区分局部变量和成员变量同名情况
this代表它所在函数所属对象的引用。
简单说：哪个对象在调用this所在函数，this就代表哪个对象

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this表示这个对象。
 但凡本类功能(函数)内部使用了本类对象，都用this表示。

this 用于区分成员变量。
     用于构造函数之间进行互相调用
this 语名只能定义在构造函数的第一行，因为初始化要行执行。

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外(p.age)，还可以直接被类名调用(person.age)，类名.静态成员。
被静态修饰后，就不在堆中，在一个单独的空间(方法区或共享区或数据区)
static特点：
 1.随着类的加载而加载。
   也就是说静态会随着类的消失而消失，说明它的生命周期最长。
 2.优先于对象的存在
   明确一点：静态是先存在，对象是后存在的。
 3.被所有对象所共享
 4.可以直接被类名所调用。

实例变量和类变量的区别：
 1.存放位置。
   类变量随着类的加载而存在于方法区中。
   实例变量随着对象的建立而存在于堆内存中。
 2.生命周期：
   类变量生命周期最长，随着类的消失而消失。
   实例变量生命周期随着对象的消失而消失。

静态使用注意事项：
 1.静态方法只能访问静态成员(变量和方法)
   非静态方法既可以访问静态也可以访问非静态。
 2.静态方法中不可以定义this，super关键字
   因为静态优先于对象存在，所在静态方法中不可以出现this。
 3.主函数是静态的。

静态有利有弊：
 利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
     可以直接被类名调用。(没对象只能用类名调用)
 弊端：生命周期过长。
       访问出现局限性。(静态虽好，只能访问静态)
class Person
{
        String name;//成员变量，实例变量。
        static String country = "CN";//静态的成员变量，类变量。
        public static void show()
        {
                System.out.println("::::");
        }
}

public static void main(String[]  args)
主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。

------0605说明文档的建立/** 内容 */
 类必须是public的 (用javadoc 编译)
 一个类中默认会有一个空参数的构造函数，这个默认的构造函数的所属类一致。
 如果类被public修饰，那么默认的构造函数也带public修饰符。
 如果类没有被public修饰，那么默认的构造函数也没有public修饰符。
 即默认构造函数的权限是随着类的变化而变化的。

------0606静态代码块
静态代码块格式：
static
{
 静态代码块中的执行语句
}
特点：随着类的加载而执行，只执行一次。用于给类进行初始化。

 静态代码块的执行顺序

*静态里面不能用this
*构造代码块能用this

 

------0607对象初始化过程
Person p=new Person("zhangsan",20);
该句话都做了什么事情?
1.因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2.执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中建立对象的特有属性。并进行默认初始化。
5.对属性进行显示初始化。
6.对对象进行构造代码块初始化。
7.对对象进行对应的构造函数初始化。
8.将内存地址会给栈内存中的p变量。

------0608
非静态省略this.
静态省略类名.
静态方法被调用只有两种方式：1对象访问，2类名访问(必须是静态的)

------0609单例设计模式
23种设计模式
对象一定在堆里
想要保证对象唯一：(想法)
1.为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
2.还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
保证对象唯一：(用代码实现)
1.将构造函数私有化。
2.在类中创建一个本类对象
3.提供一个方法可以获取到该对象。

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

称为饿汉式：(不管怎样,先拿了空间再说)
class single
{
 private static Single s=new Single();
 private Single(){}
 public static Single getInstance()  //getInstance只是一个名字，起别的也行
 {
  return s;
 }
}
方法被调用只有两种方式：1对象访问，2类名访问(必须是静态的)

------0610
对象是方法被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式(因为懒,所以到非要用的时候才拿空间)
class single
{
 private static Single s=null;
 private Single(){}
 public static synchronized Single getInstance()
 {
  if(s=null)
   s=new Single();
  return s;
 }
}
为提高效率可以用双重判断来做，以减少对锁的判断
class Single
{
 private static Single=null;
 private Single(){};
 public static Single getInstance(()
 {
  if(s=null);
  {
   synchronized (Single.class);
   {
    if(s=null);
     s=new single();
   }
  }
  return s;
 }
}

------0701
extends
继承：
1.提高了代码的复用性。
2.让类与类之间产生关系。有了这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系is a。

------0702
java语言中：java只支持单继承，不支持多继承(C++支持多继承).
多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪个。
class a
{void show(a)}
class b
{void show(b)}
class c extends a,b
c.show() //??这里就出现问题了。show方法结果不确定
在具体调用时，要创建最子类的对象，因为：1有可能父类不能创建对象，2创建子类对象可以使用更多的功能，包括基本的也包括特有的。
一句话：查阅父类功能，创建子类对象使用功能。
------0703
子父类出现后，类成员的特点：
类中成员：1、变量。2、函数。3、构造函数。
super.变量和this.变量
父类引用    子类引用
------0704
新的关键词super
1.变量
如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this；子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。

super.父类
this.子类

------0705
子父类中的函数。
覆盖:当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。

这种情况是函数的另一个特性：重写(覆盖)
当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。
覆盖注意事项：
 1.子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
 2.静态只能覆盖静态。
子类覆盖父类是功能的扩展，父类中已经有的，子类中没有必要再覆盖，直接用super.方法名调用父类就可以。
例：
class Tel
{
 void show()
 {
 System.out.println("number");
 }
}
class NewTel extends Tel
{
 void show()
 {
 super.show();//用super.方法名调用父类方法
 System.out.println("name");
 System.out.println("pic");
 }
}

已经学的权限public private 还有一种什么都不写如上面的例子。

记住：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。(包括返回值)

------0706
子父类构造函数this() super()
(构造函数不存在覆盖)  课0508构造函数特点函数名与类名相同
      子类中至少有一个构造函数访问父类
注意：super()函数写在子类构造函数的第一行
      this()函数写在构造函数的第一行
      因此，一个函数内不可能同时出现this和super

在对子类对象进行初始化时父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语名super()；
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

为什么子类一定要访问父类的构造函数。
因为父类中的数据，子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语名的方式来指定。

子类 实例化过程
结论：
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都才一句隐式super()
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少有一个构造函数会访问父类中的构造函数。
注意：super语句一定定义在子类构造函数的第一行。

------0707
final：最终。作为一个修饰符。
1.可以修饰类，函数，变量。
2.被final修饰的类不可以被继承。为了避免被继承，被子类复写功能
3.被final修饰的方法不可以被复写。
4.被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起了名字，方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多外单词组成。单词间通过下划线(_)连接。
5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
已学class修饰符(public final)
-0712类是继承关系
接口是实现关系
implements实现

------0708
abstract抽象
抽象类的特点：
1抽象方法一定在抽象类中
2抽象方法和抽象类都必须被abstract关键字修饰
3抽象类不可以用new创建对象，因为调用抽象方法没意义
4抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。
  如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类

以下论坛笔记摘抄：
下面比较一下两者的区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。

------0710
员工抽象类

------0711
模板方法
gettime程序运行时间
用到了abstract与final
------0712
接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
interface用于定义接口
接口定义时格式特点：
1.接口常见定义：常量，抽象方法。
2.接口中的成员都有固定修饰符。
 常量：public static final
 方法：public abstract
记住：接口中的成员都是public的
例：
interface Inter
{
 public static final NUM=3;
 public abstract void show();
}
class Test implements Inter//新的关键字implements
{
 public void show(){}
}
接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化，否则子类是一个抽象类。

------0713
接口可以被多实现。
一个类在继承的同时还可以实现多个接口。
例：
class Test extends Demo implements Inter,InterA//Test类继承Demo又实现了Inter和InterA
接口可以实现多继承

------0714
接口的特点：
 接口是对外暴露的规则
 接口是程序的功能扩展
 接口可以用来多实现
 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
 接口与接口之间可以有继承关系。

------0715
基本功能用类，扩展功能用接口

------0801
多态：可以理解为事物存在的多种体现形态。
例：
猫 x=new 猫
动物 x=new 猫

------0802
1,多态的体现
 父类的引用指向了自己的子类对象。
 父类的引用也可以接收自己的子类对象。
2.多态的好处
 必须是类与类之间有关系。要么继承，要么实现。
 通常还有一个前提：存在覆盖。
3.多态的弊端
 多态的出现大大的提高程序的扩展性。
4.多态的应用

以下是论坛的内容：
http://bbs.itheima.com/thread-18693-1-1.html
楼主可以记住多态的一些特点：
1：成员函数在多态调用时，编译看左边，运行看右边。
2：成员变量在多态中无论编译和运行，都参考左边。（引用型变量所属的类）
3：静态成员函数在对多态中，无论编译和运行，都参考左边。
你的属于第一种，实在不懂就硬背。

------0803
多态自始至终都是子类对象在做着变化。
instanceof关键字
a instanceof Cat//a是不是Cat这个类的类型
ClassCastException类型转换异常
------0808
object类:是所有对象的直接或者间接父类，传说中的上帝。

.equals方法
instanceof方法

------0901
内部类的访问规则：
1.内部类可以直接访问外部类中的成员，包括私有。
 之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类和引用，格式 外部类名.this。
2.外部类要访问内部类，必须建立内部类对象。
直接访问内部类中的成员：
Outer.Inner in=new Outer().new Inner();
类可以被私有吗？
内部类可以，当内部类在外部类的成员位置时，是可以被private修饰。

------0902
访问格式：
当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，可以直接建立内部类对象。
格式：
 外部类名.内部类名  变量名=外部类对象.内部类对象
 Outer.Inner in = new Outer().new Inner();

2.
当内部类在成员位置上，就可以被成员修饰符所修饰。
 比如：private:将内部类在外部类中进行封装。
  static：内部类就具备static的特性。
  当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。

  在外部其他类中，如何直接访问static内部类的非静态成员呢？
  new Outer.Inner().function();

  在外部其他类中，如何直接访问static内部类的静态成员呢？
  Outer.Inner.function();

 注意：当内部类中定义了静态成员，该内部类必须是static的。
  当外部类中的静态方法访问内部类时，内部类也必须是static的。

------0904
匿名内部类：
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式：new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖。可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。

------0905
异常：是问题的描述，将问题进行对象的封装。
异常分为两种：一种是严重的问题Error，一种是非严重的问题Exception。
throwable
  |___Error
  |___Exception
        |___RuntimeException

------0906
异常体系的特点：异常体系中的所有类以及建立的对象者具备可抛性，也就是说可以被throw和throws关键字操作。只有异常体系具备这个特点。
异常处理格式：
try
{
 需要被检测的代码；
}
catch(异常类 变量)
{
 处理异常的代码：(处理方式)
}
finally
{
 一定会执行的语句；
}
Throwable 类是 Java 语言中所有错误或异常的超类
例：
catch(Exception e)
{
 System.out.println(e.getMessage());//getMessage()是Throwable的一个方法。
}

------0907
异常可以抛出或捕捉
抛出：throws Exception
捕捉:try{} catch(Exception e){}

------0908
在声明异常时，有几个异常，就对应几个catch块。
多异常中，声名的异常越具体，处理越具体，但记得具体的异常要放在上面，父类异常要放在最下面。

------0909
自定义异常：
例：
class FuShuException extends Exception
{
 FuShuException(String msg)//父类中已经把异常信息的操作都作完了，所以子类只要在构造时，将异常信息传给父类就可以了。
 {
  super(msg);//通过父类的getMessage方法获取自定义的异常信息
 }
}

class Demo
{
 int div(int a,int b) throws FuShuException
 {
  if(b<0)
   throw new FuShuException();//手动通过throw关键字抛出一个自定义异常对象。
  return a/b;
 }
}
当在函数内部出现了throw抛出异常对象，那么就必须要给对应在的处理动作。
要么在内部try catch处理，要么在函数上声明调用者处理。

------0910
throws和throw的区别
throws使用在函数上，后面跟的是异常类，可以跟多个，用逗号隔开。
throw使用在函数内，后跟的是异常对象。

------0911
Exception中有一个特殊的子类异常RuntimeException 运行时异常。
如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。
如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。

对于异常分两种：
1.编译时被检测的异常
2.编译时不被检测的异常(运行时异常，RuntimeException以及其子类)

------1001
finally异常一定执行的代码
注意：
1，finally中定义的通常是关闭资源代码，因为资源必须释放。
2，finally只有一种情况不会执行，当执行到System.out(0);fianlly不会执行。 (jvm虚拟机退出)

------1002  异常的三种格式：
格式1
try
{}
catch
{}

格式2
try
{}
catch
{}
finally
{}

格式3
try
{}
finally
{}

记住：catch是用于处理异常，如果没有catch就人表有被处理过；如果该异常是检测时异常，那么必须声明。

------1003
异常在子父类覆盖中的体现：
1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类的子集。
3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。
 如果子类方法发生了异常，就必须要进行try处理。绝对不能抛出。

------1004
求正方形和圆形的面积

------1005
总结：当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败。
 注意：RuntimeException除外，也就是说，函数内如果抛出是RuntimeException异常，函数上可以不用声明。
 如果函数声明了异常，调用者需要进行处理。处理方法可以throws或try。

异常的好处：1，将问题进行封装。2，将正常流程代码和问题处理代码相分享，方便于阅读。
异常的处理原则：
1，处理方式有两种：try或者throws
2，调用到抛出异常的功能时，抛出几个，就处理几个。
3，多个catch，父类的catch放到最下面。
4，catch内，需要定义针对性和处理方式，不要简单的定义printstrackTrace,输出语句。也不要什么都不写。
 当捕获到的异常，本功能处理不了时，可以继续catch中抛出。
 try
 {
  throw new AException();
 }
 catch(AException e)
 {
  throw e;
 }

 如果该异常处理不了，但并不异于该功能出现的异常。可以将异常转换后，再抛出和该功能相关的异常。
 try
 {
  throw new AException();
 }
 catch(AException e)
 {
  throw new BException();
 }
 或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去

------1006
练习，要看一看

第十一题：
class Fu
{
 int num=4;
 void show()
 {
 System.out.println("showFu");
 }
}
class Zi extends Fu
{
 int num=5;
 void show()
 {
 System.out.println("showZi");
 }
}
calss T
{
 public static void main(String[] args)
 {
  Fu f=new Zi();
  Zi z=new zi();
  System.out.println(f.num);
  System.out.println(z.num);
  f.show();
  z.show();
 }
}
程序输出结果4，5，showzi,showzi
查看0802论坛笔记

 

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