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();
}

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页