java学习笔记

                                     javase学习笔记之高级类特性

 

A1.面向对象三大特性：封装 继承 多态

1.封装：  一个类封装了数据以及操作数据的代码逻辑体。定义了数据的可访问属性（私有、公有）

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作，便于修改，增强代码的可维护性；

2.继承 ： 可以让一个类型获取另外一个类型的属性的方式。

概念：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。此处的多个类称为子类，单独的这个类称为父类（基类或超类）。可以理解为:“子类 is a 父类”

作用：继承的出现提高了代码的复用性。 继承的出现让类与类之间产生了关系，提供了多态的前提。 不要仅为了获取其他类中某个功能而去继承

重点：

（1）子类继承了父类，就继承了父类的方法和属性。

（2）在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。

（3）在Java 中，继承的关键字用的是“extends”，即而子类不是父类的子集，而是对父类的“扩展”。

（4）Java只支持单继承，一个子类只能有一个父类 一个父类可以有多个子类。

关于继承的规则： 子类不能直接访问父类中私有的(private)的成员变量和方法

3.多态 ： 类实例的一个方法在不同情形下有不同的表现形式，即不同的外在行为。使具有不同的内部结构的对象可以共享相同的外部接口。

在java中有两种体现：

方法的重载(overload)和重写(overwrite)。 对象的多态性   ——可以直接应用在抽象类和接口上。

（1）Person p = new Student();    向上转型；

p.walk（）；调用了学生的走路方法

Student s= Student(p);向下转型；利用强转符。

s.eat（）；调用了学生的吃饭方法

（2）程序分为编译状态和运行状态。

对于多态性来说，编译时“看左边”将此应用变量理解为父类类型，

运行时，“看右边”关注正真对象的实体，子类对象，那么执行的方法是子类重写的。

子类特有的  父类无法调用。

（3）多态的必要二个条件：1.继承 2.重写父类引用指向子类对象

（4）多态的实现方法：1.重写2.接口3.抽象类和抽象方法；

（5）子类的多态性并不适应于属性。

多态举例：

public class Test{     

public void method(Person e) { //Person是Student父类；

               //……               

           e.getInfo();   

 }     

public static  void main(Stirng args[]){               

Test t = new Test();                 

Student s = new Student();

 t.method(s);    //子类的对象m传送给父类类型的参数e     }

}

A2.重写与重载

1.重写：子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。

      1）参数列表必须完全与被重写方法的相同；

      2）访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。否则会有以下信息：Cannot reduce the visibility of the inherited method from Base

      3）父类的成员方法只能被它的子类重写。

      4）声明为final的方法不能被重写。

      5）声明为static的方法不能被重写，但是能够被再次声明。（static和final的都不能被重写）

      6）子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。

      7）子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。

      8）构造方法不能被重写。（构造方法属于static的）

     9）如果不能继承一个方法，则不能重写这个方法。

Super关键字的使用

当需要在子类中调用父类的被重写方法时，要使用super关键字。

class Animal{
   public void eat(){
      System.out.println("动物可以吃饭");
   }
}
 
class Dog extends Animal{
   public void eat(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以吃饭");
   }
}
 
public class TestDog{
   public static void main(String args[]){
 
      Animal b = new Dog(); // Dog 对象
      b.eat(); //执行 Dog类的方法
 
   }
}

2.重载：是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

重载规则:

被重载的方法参数个数或类型不一样；

被重载的方法可以改变返回类型；

被重载的方法可以改变访问修饰符；

方法能够在同一个类中或者在一个子类中被重载。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

A3.final：最终的。

基本用法：

1.可以修饰类： 被修饰的类不能被继承

2.可以修饰方法：方法不能被重写；基本类型：值不能改变，引用类型：地址值不能改变，对象中的属性可以改变。利用set方法

3.可以修饰变量：　修饰变量是final用得最多的地方，

！！！如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

public class car{

private final int i=1；
public car(){
int=2;//此时会报错
final Object ob=new Object();
ob=new Object();//会报错
}
}

通常与public static final 连用为全局常量  访问变得很方便，而且不会被修改。一般可以放配置信息，还有一些状态码的定义。

A4.static:静态的可以用来修饰属性方法，代码块（或初始化块），内部类，不能构造器。

static修饰属性（类变量）：静态变量

1.由类创建的所有的对象，都公用一个属性，在内存中只有一个副本。

2.当其中一个对象对静态变量进行修改的时候，会导致其他对象对此属性的一个调用。 非静态变量又为实例变量（存在多个副本，各个对象拥有的副本互不影响）。

3.静态变量是通过类的创建而加载的。

4.静态变量可以通过“类.静态变量”的形式调用。

5.静态变量的加载要早于对象，当有对象的时候可以通过“对象.静态变量”调用，但是“类.非静态变量”不行（因为非静态变量随着对象的创建而加载，非静态变量的加载要晚于类的创建）

static修饰方法（静态方法）

1.随着类的创建而加载，在内存中也只有一份。

2.可以直接用“类.静态方法”调用。

3.在静态方法内部可以调用静态的属性跟方法，而不能调用非静态的属性方法。反之非静态的方法可以调用静态的属性跟方法。

4.因为静态方法不依附于任何对象，既然都没有对象，就谈不上this了。静态方法里面是不能有this和super关键字。

注：静态的结构（static的属性方法代码块内部类）的生命周期要早于非静态的结构。

static代码块

　　static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。

       static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

A5.抽象类与抽象方法（abstract）：

抽象类是为了把相同的但不确定的东西的提取出来，为了以后的重用。定义成抽象类的目的，就是为了在子类中实现抽象类。

1.abstract修饰类：（1）不能被实例化（不能创建对象）。

                               （2）抽象类可以有构造器，也可以定义构造器。（凡是类都有构造器）

                               （3）抽象方法所在的类一定是抽象类。

                               （4）抽象类中可以没有抽象方法。一旦类中包含了abstract方法，那类该类必须声明为abstract类。

2.abstract修饰方法：

（1）格式：没有方法体 没有{ }如： public abstract void eat();

（2）抽象方法只保留功能，具体执行交给子类，由子类重写此抽象方法。

（3）若子类继承抽象类，没有重写所有的抽象方法，意味着自雷肯定还有抽象类，则子类必须声明抽象类才可以。

abstract class person(){
    public abstract void eat();只保留了功能，具体实现交给子类。
public person(){
}//可以有构造器

}
class student extends person(){
public void eat(){
System.out.println("学生吃饭")
}
}

限制：不能abstract修饰属性 私有方法 构造器  final方法。

A6.接口（Interface）：

在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

1.接口可以说是一个特殊的抽象类，是常量与抽象方法的一个集合。（不能包含变量和一般的方法）而类描述对象的属性和方法。接口要定义的一种功能，此功能会被类要实现的方法。

2接口不能用于实例化对象。接口没有构造方法。

3.接口中所有的方法必须是抽象方法。

4.实现接口的类，必须重写其中所有的抽象方法，方可实例化，若没有重写所有的抽象方法，则此类还是一个抽象类。

5.类可以实现多个接口------------Java中类的继承属于单继承

6.接口与接口之间属于继承关系，实现多继承

7.接口与具体实现类之间有多态性

特性：

1.接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

2.接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

interface AA{
int i=4；//所有的常量都是由public static final修饰

Boolean flag=false；
void method1（）;//抽象方法：所有的方法都是由public abstract修饰
void method2（）;

}
abstract class CC implements AA{
//若没有重写接口类的方法则此类必须是抽象类。

}
class BB implements AA{

public voidmethod1(){
}
public voidmethod2(){
}
}
interface DD{
void method3();
}
interface EE extends AA, DD{//接口中可以实现多继承。
void method1();
void method2();
void method3();
}