第8天 静态函数、main方法、单例模式、instanceof

1.复习

构造函数：

 构造函数的作用： 初始化对应的对象。

 构造函数的格式：

 修饰符  函数名(形式参数){

 函数体

 }

 构造函数要注意的事项：

 1. 构造函数是没有返回值类型的。

 2. 构造函数的函数名是必须与类名一致。

 3. 构造函数不是由我们手动调用的，是我们在创建了对应的对象时，jvm会根据你创建的对象传递的参数调用

 对应 的对象。

 4. 如果一个类没有显示写上一个构造函数的时候，那么java编译器会为该类添加一个无参 的构造函数。

 5. 如果一个类已经显示写上一个构造函数的时候,那么java编译器则不会再为该类添加一个无参 的构造函数。

 6. 构造函数是可以以函数重载的形式存在多个。

 构造代码块：

 构造代码块的作用：给对象进行统一的初始化。

 构造代码块 的格式：

 {

 代码；

 }

 构造代码块是在创建了代码块所属类的对象时调用一次。

 this关键字：

 this关键字代表了所属函数的调用者对象。

 this关键字的作用：

 1.  一个类中存在同名的成员变量与局部变量时，在方法的内部默认是访问局部变量的，可以通过this关键字指定访问成员变量 的数据。

 2.  this关键字还可以在构造函数中调用另外一个构造函数初始化对象，

 this关键字调用构造函数要注意的事项：

 1. this关键字调用其他 的构造函数时，必须要是在第一个语句。

 2. this关键字调用构造函数时不能出现相互调用，因为是一个死循环。  

 3. 如果在方法的内部访问一个变量时，该变量只存在于成员变量中，局部没有没有，这时候java编译器会为该变量的前面添加this关键字。

 static（静态、修饰符）

 static修饰成员变量时：static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.

2.静态函数

1)静态成员变量的访问方式：

 方式一： 使用对象进行访问。

 对象.属性名

 方式二：可以使用类名进行访问。

 类名.属性名

 注意：

 1. 非静态成员变量不能类名直接访问，只能使用对象进行访问。

 2. 千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据 时才使用static修饰。

2)static修饰方法(静态的成员方法)

访问方式：

方式一：可以使用对象进行访问。

对象.静态的函数名();

方式二：可以使用类名进行访问。

类名.静态函数名字。

推荐使用是类名直接访问静态的成员。

3)静态的成员变量与非静态成员变量的区别

1.作用上的区别：

a)  静态的成员变量的作用共享一个数据给所有的对象使用。

b)  非 静态的成员变量的作用是描述一类事物的公共属性。

2.数量与存储位置上的区别：

a)静态成员变量是存储方法区内存中，而且只会存在一份数据。

b)非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。

3.生命周期的区别：

a)静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。

b)非静态的成员数据是随着对象的创建而存在，随着对象被垃圾回收器回收而消失。

4）静态函数要注意的事项

1.静态函数是可以调用类名或者对象进行调用的，而非静态函数只能使用对象进行调用。

2.静态的函数可以直接访问静态的成员，但是不能直接访问非静态的成员。

原因：静态函数是可以使用类名直接调用的，这时候可能还没有存在对象，而非静态的成员数据是随着对象 的存在而存在的。

3.非静态的函数是可以直接访问静态与非静态的成员。

原因：非静态函数只能由对象调用，当对象存在的时候，静态数据老早就已经存在了，而非静态数据也随着对象的创建而存在了。

4.静态函数不能出现this或者super关键字。

原因：因为静态的函数是可以使用类名调用的，一旦使用类名调用这时候不存在对象，而this关键字是代表了一个函数 的调用者对象，这时候产生了冲突。

静态的数据的生命周期：静态的成员变量数据是优先于对象存在的。

5)static什么时候修饰一个函数

如果一个函数没有直接访问到非静态的成员时，那么就可以使用static修饰了。 一般用于工具类型的方法

6)静态函数不能访问非静态成员？

静态函数只要存在有对象，那么也可以访问非静态的数据。只是不能直接访问而已。

7)静态函数代码实例

<span style="font-family:Microsoft YaHei;font-size:12px;">class Student{String name; //名字staticString country = "中国"; //国籍//静态代码块 ：静态代码块是在Student.class文件加载到内存的时候就马上执行的。static{System.out.println("静态代码块执行了...");}//构造函数public Student(String name){this.name = name;}//非静态的成员函数public  void study(){System.out.println("好好学习"+this);}//静态函数public static void sleep(){  //静态方法与非静态方法的字节码文件是同时存在内存中 的。 只是静态的成员变量数据是优先于对象存在而已。Student s= new Student("铁蛋");System.out.println(s.name+"呼呼大睡...");}}class Demo2 {public static void main(String[] args) {Student.sleep();//Student s = new Student("狗娃");}}</span>

3.main方法的详解

主函数是静态的

public static voidmain(String[] args){

 

}

ü  public：公共的。 权限是最大，在任何情况下都可以访问。 private

原因： 为了保证让jvm在任何情况下都可以访问到main方法。

ü  static:  静态。静态可以让jvm调用main函数的时候更加的方便。不需要通过对象调用。

ü  void:  没有返回值。 因为返回的数据是 给 jvm，而jvm使用这个数据是没有意义的。所以就不要了。

ü  main:函数名。   注意：main并不是关键字,只不过是jvm能识别的一个特殊的函数名而已。

ü  arguments：担心某些程序在启动需要参数。

4.单例设计模式

模式：模式就是解决一类 问题的固定步骤 。

软件行业中的23种设计模式，其中常见的有

ü  单例设计模式

ü  模板设计模式

ü  装饰者设计模式

ü  观察者设计模式

ü  工厂设计模式

单例设计模式：保证一个类在内存中只有一个对象。

饿汉单例设计模式

   1. 私有化构造函数。

   2. 声明本类的引用类型变量，并且使用该变量指向本类对象。

   3. 提供一个公共静态的方法获取本类的对象。

a)饿汉单例设计模式 ----> 保证Single在在内存中只有一个对象。

<span style="font-family:Microsoft YaHei;font-size:12px;">class Single{//声明本类的引用类型变量，并且使用该变量指向本类对象private staticSingle s = new Single();//私有化构造函数private Single(){}//提供一个公共静态的方法获取本类的对象publicstatic  Single getInstance(){return s;}}</span>

b)懒汉单例设计模式

   1. 私有化构造函数。

   2. 声明本类的引用类型变量，但是不要创建对象，

   3. 提供公共静态 的方法获取本类 的对象，获取之前先判断是否已经创建了本类 对象

   ，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，

   然后再返回。

懒汉单例设计模式 ----> 保证Single在在内存中只有一个对象。

<span style="font-family:Microsoft YaHei;font-size:12px;">class Single2{//声明本类的引用类型变量，不创建本类的对象private static Single2 s;//私有化了构造函数private Single2(){}public static Single2 getInstance(){if(s==null){s = new Single2();}return s;}}</span>

推荐使用： 饿汉单例设计模式。  因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。

5.继承

1：描述一个学生类

      1：姓名年龄学号属性，学习的方法

2：描述一个工人类

      1：姓名年龄工号属性，工作的方法

3：描述一个人类

      1：姓名年龄属性，说话的方法。

4：发现学生类和人类天生有着联系，学生和工人都是人。所以人有的属性和行为学生和工人都会有。出现类代码重复

<span style="font-family:Microsoft YaHei;font-size:12px;">class Person {String name;int age;// 静态变量（类变量）对象和对象之间的代码重复使用静态变量static String country = "CN";Person() {}void speak() {System.out.println(name + ":哈哈，我是人！！！");}}// 让学生类和人类产生关系，发现学生is a 人，就可以使用继承class Student {String name;int age;Student() {}void study() {System.out.println("姓名：" + name + "年纪：" + age + ":好好学习");}}class Worker {String name;int age;void work() {System.out.println(name + ":好好工作，好好挣钱。");}}class Demo1 {public static void main(String[] args) {Student s = new Student();s.name = "jack";s.age = 20;s.study();Worker w = new Worker();w.name = "rose";w.work();}}</span>

5：问题:

      1：如果没有继承,出现类和类的关系无法描述

      2：如果没有继承，类和类之间有关系会出现类和类的描述代码的重复。

6.继承的特点

ü  描述类和类之间的关系

ü  降低类和类之间的重复代码

ü  降低对象和对象之间的代码重复使用静态变量

ü  降低类和类之间的代码重复使用就继承

继承：继承是通过关键字extends体现的。

继承的格式：

   class 类名1 extends 类名2{

   }

7.继承的细节

n  类名的设定，被继承的类称之为父类(基类)，继承的类称之为子类

n  子类并不能继承父类中所有的成员

ü  父类定义完整的成员 静态成员，非静态，构造方法。静态变量和静态方

ü  法都可以通过子类名.父类静态成员的形式调用成功。

u 所有的私有成员不能继承,private修饰的成员。

u 构造函数不能被继承

8.如何使用继承

ü  不要为了使用继承而继承。工人和学生都有共性的成员，不要为了节省代

9.继承需要注意的事项

ü  千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。

ü  父类私有的成员不能被继承。

ü  父类的构造函数不能被继承。

ü  创建子类对象时默认会先调用父类无参的构造函数。

10.继承代码实例

<span style="font-family:Microsoft YaHei;font-size:12px;">class Person{String name;privateint age;public  Person(String name){this.name = name;}public Person(){System.out.println("Person类的构造方法被调用了....");}public void eat(){System.out.println(name+"在吃饭...");}}//学生类class Student1 extends Person {  // Student 就称作为Person类的子类， Person类就称作为Student的父类(超类、基类)int num; //学号public Student1(){System.out.println("Student类的构造方法被调用了....");}public void study(){System.out.println(name+"good good study , day day up");}}class Demo7 {public static void main(String[] args) {Student1 s = new Student1();s.name = "狗娃";System.out.println("名字："+ s.name);s.eat();}}</span>

6.super关键字、方法的重写

super关键字：

super关键字代表了父类空间的引用。

super关键字的 作用：

   1. 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。

   2. 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

super关键字调用父类构造方法要注意的事项：

   1. 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。

   2. super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。

   3. super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。

super关键字与this关键字的区别：

   1. 代表的事物不一致。

        1. super关键字代表的是父类空间的引用。

        2. this关键字代表的是所属函数的调用者对象。

   2. 使用前提不一致。

        1. super关键字必须要有继承关系才能使用。

        2. this关键字不需要存在继承关系也可使用。

   3. 调用构造函数的区别：

        1. super关键字是调用父类的构造函数。

        2. this关键字是调用本类的构造函数。

<span style="font-family:Microsoft YaHei;font-size:12px;">class Fu{int x = 10;String name;public Fu(){System.out.println("Fu类无参的构造方法..");}public Fu(String name){this.name = name;System.out.println("Fu类带参的构造方法..");}public void eat(){System.out.println("小头爸爸吃番薯..");}}class Zi extends Fu{int x = 20; int num;public Zi(String name,int num){super(name); //指定调用了父类带参的 构造方法...this(); // 调用本类无参构造方法..//super(); //指定调用了父类无参构造方法。。。System.out.println("Zi类带参的构造方法..");}public Zi(){System.out.println("Zi类无参的构造方法..");}public void print(){System.out.println("x = " +super.x);public void eat(){System.out.println("大头儿子吃龙虾..");}}class Demo9 {public static void main(String[] args) {Zi z = new Zi("狗娃");}}</span>

<span style="font-family:Microsoft YaHei;font-size:12px;">/*目前的问题：父类的功能无法满足子类的需求。方法重写的前提： 必须要存在继承的关系。方法的重写: 子父类出了同名的函数，这个我们就称作为方法的重写。什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。方法重写要注意的事项：1.方法重写时， 方法名与形参列表必须一致。2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。Exception(最坏)RuntimeException(小坏)方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。方法重载的要求1. 函数名要一致。2. 形参列表不一致（形参的个数或形参 的类型不一致）3. 与返回值类型无关。*/class Animal{  //大的数据 类型 }class Fish extends Animal{  //Fish小 的数据类型。}class Fu{String name;public Fu(String name){this.name = name;}public Animal eat() throws RuntimeException {System.out.println(name+"吃番薯...");return new Animal();}}class Zi extends Fu{String num;public Zi(String name){super(name);//指定调用 父类带参的构造方法}//重写父类的eat方法public Animal eat() throws Exception{System.out.println("吃点开胃菜..");System.out.println("喝点汤....");System.out.println("吃点龙虾....");System.out.println("吃青菜....");System.out.println("喝两杯....");System.out.println("吃点甜品....");return new Animal();}}class Demo10{public static void main(String[] args) {Zi z = new Zi("大头儿子");z.eat();}}</span>

7.继承练习

需求：使用java描述一下普通的学生、 java基础班的学生、 就业班的学生。

所有的学生都会学习。但是学习的内容不一样。

普通 的学生： 马克思列宁主义。

基础班的学生：学习的是 javase。

就业班学生： javaee+android.

//普通的学生类

<span style="font-family:Microsoft YaHei;font-size:12px;">class Student{String name;//构造函数public Student(String name){this.name = name;}public void study(){System.out.println(name+"学习马克思列宁主义");}}//基础班的学生是属于学生中一种class BaseStudent extends Student{public BaseStudent(String name){super(name);//指定调用父类构造函数}//重写public void study(){System.out.println(name+"学习javase..");}}//就业班学生 也是属于普通学生中一种class WorkStudent extends Student{//构造 函数public WorkStudent(String name){super(name);}//重写public void study(){System.out.println(name+"学习javaee+android..");}}class Demo11 {public static void main(String[] args) {//System.out.println("Hello World!");BaseStudent s = new BaseStudent("居东东");s.study();//创建一个就业班的学生WorkStudent w = new WorkStudent("张三");w.study();}}</span>

8.instanceof关键字

1：快速演示instanceof

Personp=new Person();

      System.out.println( p instanceof Person);

   2：instanceof是什么？

      1：属于比较运算符：

      2：instanceof关键字：该关键字用来判断一个对象是否是指定类的对象。

      3：用法：

              对象  instanceof 类;  

     该表达式是一个比较运算符，返回的结果是boolea类型 true|false

   注意：使用instanceof关键字做判断时，两个类之间必须有关系。

<span style="font-family:Microsoft YaHei;font-size:12px;">class Animal{String name;String color;public Animal(String name, String color){this.name = name;this.color = color;}}//狗是属于动物中一种class Dog extends Animal {public Dog(String name,String color){super(name,color); //指定调用父类两个 参数的构造函数。}public void bite(){System.out.println(name+"咬人!!");}}//老鼠 也是属于动物中一种class Mouse extends  Animal{public Mouse(String name,String color){super(name,color);}public void dig(){System.out.println(name+"打洞..");}}class Demo12{public static void main(String[] args) {Dog d = new Dog("哈士奇","白色");System.out.println("狗是狗类吗？"+ (d instanceof Dog));System.out.println("狗是动物类吗？"+ (d instanceof Animal));//System.out.println("狗是老鼠类吗？"+ (d instanceof Mouse));// false trueAnimal a = new Animal("狗娃","黄色"); //狗娃是人System.out.println("动物都是狗吗？"+ (a instanceof Dog));}}</span>