黑马程序员——Java基础——构造方法，static关键字，以及继承的详解

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

构造方法

构造方法作用概述                                                                        

给对象的数据进行初始化

构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值

举例演示：

class Student{

            String name;

                 //构造方法

           public Student(){

                  System.out.println("我是构造方法");

                 name = "小明";

           }

 }

 class OOPDemo {

              public static void main(String[] args) {

                            //创建对象

                         Student s = new Student();

                         System.out.println( s.name );

            }

}

构造方法注意事项

如果你不提供构造方法，系统会给出空参数的构造方法
如果你提供了构造方法，系统将不再提供空参数的构造方法

构造方法也是可以重载的

举例演示：

class Student {

         String name;

            //空参数构造方法

            public Student(){

                      System.out.println("我是空参数构造方法");

        }

               //有参数构造方法重载 

            public Student(String name){     

                      System.out.println("我是有参数构造方法");

             //为了给对象中的name成员赋值

                        this.name = name;                

           }

}  

 class OOPDemo2 {

             public static void main(String[] args) {

                                 Student s = new Student();

                                 Student s2 = new Student("小明");

                                  System.out.println(s2.name);

           }

}

构造方法注意事项

如果你不提供构造方法，系统会给出空参数的构造方法
如果你提供了构造方法，系统将不再提供空参数的构造方法

构造方法也是可以重载的

举例演示：

class Student {

         String name;

            //空参数构造方法

            public Student(){

                      System.out.println("我是空参数构造方法");

        }

               //有参数构造方法重载 

            public Student(String name){     

                      System.out.println("我是有参数构造方法");

             //为了给对象中的name成员赋值

                        this.name = name;                

           }

}  

 class OOPDemo2 {

             public static void main(String[] args) {

                                 Student s = new Student();

                                 Student s2 = new Student("小明");

                                  System.out.println(s2.name);

           }

}

成员方法的分类:
返回值：
有返回值的方法
没有返回值的void方法

参数列表:
空参数方法
有参数方法


创建一个对象的步骤:
Student s = new Student();

加载Student.class文件进内存
在栈内存为s开辟空间
在堆内存为学生对象开辟空间
对学生对象的成员变量进行默认初始化
对学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕，把对象地址赋值给s变量


 变量的定义
成员变量： 这个变量是否属于事物中的属性

特点：变量的使用范问越小越好

static关键字
可以修饰成员变量和成员方法

static关键字特点
静态所修饰的成员，随着类的加载而加载，优先于对象存在
静态所修饰的成员，会被所有对象共享
可以通过类名调用
类名.静态成员

举例演示：
  class Person{

       String name;

       int age;

             //String country;//国家  

            static String country;//国家

             //构造方法

            //空参数构造方法

             public Person(){}

            //有参数构造方法

        public Person(String name, int age, String country){

                             this.name = name;

                             this.age = age;

                             this.country = country;

          }

       public void show(){

               System.out.println(name + ".." + age + ".." + country);

       }

} 

    class StaticDemo {

        public static void main(String[] args) {

                       //创建第一个对象

                         Person p1 = new Person("刘德华", 45, "中国");

                                    p1.country = "美国";

                      //创建第二个对象

                    Person p2 = new Person();p2.name = "张学友";

                     //创建三个对象

                    //Person p3 = new Person("张柏芝" , 40, "中国");

                    Person p3 = new Person();p3.name = "张柏芝";

                           p1.show();

                           p2.show();

                           p3.show();

                     //可以通过类名调用

                    //类名.静态成员名

                     Person.countrySystem.out.println(Person.country);}}

static关键字注意事项
在静态方法中是没有this关键字的
静态方法只能访问静态的成员变量和静态的成员方法
静态只能访问静态

举例演示：

class Demo{

             //普通的成员变量

                 int num = 10;

             //静态的成员变量

               static int num2 = 20;

             //普通的成员方法

        public void method(){

                System.out.println( num );

                System.out.println( num2);

                      function();function2();

             }

                 //普通方法

        public void function(){

                         System.out.println("我是普通方法");

         }

                  //静态方法

        public static void method2(){

               //System.out.println( num );// 错误: 无法从静态上下文中引用非静态 变量 num

               //System.out.println( this.num2);//错误: 无法从静态上下文中引用非静态 变量 thisSystem.out.println(num2);

               //function();//错误: 无法从静态上下文中引用非静态 方法 function()function2();

           }

               //静态方法

        public static void function2(){

                 System.out.println("我是静态方法");

         }

}

    class StaticDemo2 {

                  public static void main(String[] args) {

                                  //创建对象

                             Demo d = new Demo()

                          ;//d.method();

                             d.method2();

                   }

   }

继承：
概念：继承是从已有的类中派生出新的类，
新的类能吸收已有类的数据属性和行为，并能扩展新的能力。


(了解)继承的好处和弊端
提高了代码的复用性
多个类相同的成员可以放到同一个类中
提高了代码的维护性
如果功能的代码需要修改，修改一处即可
让类与类之间产生了关系，是多态的前提

其实这也是继承的一个弊端：类的耦合性很强

举例演示：

 class Person{
//成员变量
private String name;
private int age;
//构造方法
public Person(){}
public Person(String name, int age){
this.name = name;
this.age = age;
}
//提供公共访问方法,setXxx() getXxx()
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}


//学习方法
public void study(){
System.out.println("学习Java");
}
}


//class 老师类 extends 人类
class Teacher extends Person {
}


//class 学生类 extends 人类
class Student extends Person {
}




class ExtendsDemo2 {
public static void main(String[] args) {
//创建老师类对象
Teacher t1 = new Teacher();
t1.setName("周瑜");
t1.setAge(27);


System.out.println( t1.getName() + "..." + t1.getAge());
}
}


继承特点
Java只支持单继承，不支持多继承
Java支持多层继承(继承体系)

举例演示：

class Yy{
int num2 = 11;
}


class Fu extends Yy {
int num = 10;
}


class Fu2{
}


//class Zi extends Fu,Fu2{//报错，java中的类只支持单继承，不支持多继承
class Zi extends Fu { }


class ExtendsDemo3 {
public static void main(String[] args) {
//创建子类对象
Zi z = new Zi();
System.out.println( z.num  );
System.out.println( z.num2 );
}
}

继承的注意事项：
子类只能继承父类所有非私有的成员(成员方法和成员变量)
其实这也体现了继承的另一个弊端：打破了封装性
子类不能继承父类的构造方法，
但是可以通过super(后面讲)关键字去访问父类构造方法
不要为了部分功能而去继承

 class Fu{
//成员变量
String name = "张";
private int money = 5000;//私有


//构造方法
public Fu(){}
public Fu(String name){
this.name = name;
}


//成员方法
public void method(){
System.out.println("我是public 公共方法");
}


//私有的成员方法
private void method2(){
System.out.println("我是私有方法");
}
}


class Zi extends Fu{
//构造方法
public Zi(){
}
}


class ExtendsDemo4 {
public static void main(String[] args) {
Zi z = new Zi();
System.out.println( z.name );
//System.out.println( z.money );// 错误: money可以在Fu中访问private


//调用方法
z.method();
//z.method2();// 错误: 找不到符号  ,  符号:   方法 method2()


//----------------------------------
//创建对象
Zi z = new Zi("张三");//错误: 无法将类 Zi中的构造器 Zi应用到给定类型;
         //原因: 实际参数列表和形式参数列表长度不同
}
}

继承中构造方法的注意事项:
子类通过super去显示调用父类其他的带参的构造方法
super(参数列表)
子类通过this去调用本类的其他构造方法
this(参数列表)
一定要注意
super(…)或者this(….)必须出现在第一条语句上
否则，就会有父类数据的多次初始化


方法重写
子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。

使用特点
如果方法名不同，就调用对应的方法
如果方法名相同，最终使用的是子类自己的

方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，
可以重写父类中的方法，
这样，即沿袭了父类的功能，又定义了子类特有的内容

举例演示：

class Fu{
public void method(){
System.out.println("我是父类方法");
}
}
class Zi extends Fu{
//方法重写，方法覆盖
public void method(){
super.method();
System.out.println("我是子类方法");
}
}
class ExtendsDemo9 {
public static void main(String[] args) {
//创建对象
Zi z = new Zi();
z.method();
//super.method();
}
}

方法重写的注意事项：
1：父类中私有方法不能被重写
2：子类重写父类方法时，访问权限不能更低
3：父类静态方法，子类也必须通过静态方法进行重写。
其实这个算不上方法重写，但是现象确实如此，
至于为什么算不上方法重写，多态中我会讲解

举例演示：

class Fu{

       //私有方法

              private void method(){

                     System.out.println("我是父类私有方法");

    }

                       void function(){

                     System.out.println("我是父类function方法");

  }

        //静态方法

              public static void show(){

                      System.out.println("我是父类静态方法");

               }

 }

 class Zi extends Fu{

         //重写父类的私有方法

              public void method(){

        //super.method();//访问父类方法 错误: method()可以在Fu中访问privateSystem.out.println("我是子类私有方法");

  }

           //重写父类的方法//private void function(){// 错误: Zi中的function()无法覆盖Fu中的function()

           //void function(){

           //protected void function() {

                  public void function() {

                     System.out.println("我是子类function方法");}

                   //重写父类的静态方法//public void show(){//错误: Zi中的show()无法覆盖Fu中的show() ,被覆盖的方法为staticpublic static void show(){System.out.println("我是子类的静态方法");

       }

 }

                 class ExtendsDemo10 {

                         public static void main(String[] args) {

                                   Zi z = new Zi();

                                    //z.method();

                                    //z.function();z.show();

                    }

                 }

final关键字
final关键字是最终的意思

修饰类，类不能被继承
修饰变量，变量就变成了常量，只能被赋值一次
修饰方法，方法不能被重写

举例演示：

/final class Fu {//错误: 无法从最终Fu进行继承
class Fu {
//nt num = 10;
final int num = 10;


//public void method(){
public final void method(){
System.out.println("我是Fu类方法");
}
}


class Zi extends Fu{
//子类重写父类方法
/*
public void method(){//错误: Zi中的method()无法覆盖Fu中的method()
System.out.println("我是Zi类方法");
}
*/


}




class FinalDemo {
public static void main(String[] args) {
Zi z = new Zi();
//z.num = 20;//错误: 无法为最终变量num分配值
//System.out.println(z.num);
z.method();


}
}