JAVA基础--继承、访问控制

来源：互联网发布：linux查看网卡流量编辑：程序博客网时间：2024/05/18 02:13

JAVA基础--继承、访问控制

2017-7-6

一、泛化的过程

表示类与类之间的继承关系，接口与接口之间的继承关系。

extends 单继承

class T extends parent

继承中的构造方法

1.构造方法要么全写（带参数的，不带参数的都添加）要么不写

2.子类对象构造过程在子类的构造方法里，编译器会默认添加super()，

调用父类无参的构造方法【要想编译通过，父类的无参的构造方法必须创建】

package zhangyu201776;

public class Foo {
     int num;
     Foo(){

     }
     Foo(int num){

     }
}

package zhangyu201776;

public class Goo extends Foo {
     int value;
     Goo(int value){
          //super();
          //super(1);
          this.value=value;
     }
}

父类的引用可以指向子类的对象

一个子类的对象可以向上造型为父类的类型

package zhangyu201776;

public class Foo {
     int num;
     Foo(){

     }
     Foo(int num){

     }
     public void f(){
          System.out.println("Foo.f");
     }
}

package zhangyu201776;

public class Goo extends Foo {
     int value;
     Goo(){

     }
     Goo(int value){
          //super();
          //super(1);
          this.value=value;
     }
     public void g(){
          System.out.println("goo.g");
     }
}

package zhangyu201776;

public class Test {
     public static void main(String[] args){
     Goo goo=new Goo();
     Foo foo=new Foo();
     Foo fo=new Goo();
     fo.f();
     fo.f();
     }
}

package Practice;

public class Sub extends Base {
     String color;
     public Sub(double size,String name,String color){
          super(size,name);
          this.color=color;
     }

     public static void main(String[] args){
          Sub s=new Sub(5.6,"测试对象","红色");
          System.out.println(s.size+"--"+s.name+"--"+s.color);
     }
}


package Practice;

public class Base {
     double size;
     String name;

     public Base(double size,String name){
          this.size=size;
          this.name=name;
     }
}

二、方法的重写

子类可以重写继承父类的方法，即方法名和参数列表与父类的方法相同，但方法的实现不同；

运行时绑定指向哪个对象就调用哪个对象的方法

在java中，类的继承关系可以产生一个子类，子类继承父类，它具备了父类所有的特征，继承了父类所有的方法和变量。子类可以定义新的特征，当子类需要修改父类的一些方法进行扩展，增大功能，程序设计者常常把这样一种操作方法称为重写，也称为覆写和覆盖。

如果要调用父类中的方法，可以使用super关键词实现这个功能，super关键词可以从子类访问父类中的内容。

方法重写的规则：

1、父类方法的参数列表必须完全与子类重写方法的参数列表相同，否则不能称为重写而是重载。

2、父类的返回类型必须与子类重写的方法返回类型相同，否则不能称为重写而是重载。

3、规定被子类重写的方法不能拥有比父类更加严格的访问权限。

父类中的方法并不是在任何情况下都可以重写的，当父类中方法的访问权限修饰符为private时，该方法只能被自己的类访问，不能被外部的类访问，在子类是不能被重写的。如果定义父类的方法为public，在子类定义为private，程序运行时就会报错

4、如果某一个方法中父类的访问权限是private,那么不能在子类中进行重写。

方法的重写与重载的区别

1、重载是在同一个类里面是在编译期重载绑定

2、重写是在有继承关系的基础上，运行期绑定

public class Super {
     public void f(){
          System.out.println("super.f()");
     }
}

public class Sub extends Super {
     public void f(){
          System.out.println("sub.f()");
     }

三、修饰词

package 语句

定义类时需要指定类的名称，但如果仅仅将类名作为类的唯一标识，则不可避免的出现命名冲突问题，这会给组件复用以及团队间合作造成很大的麻烦

在java中，用包的概念来解决命名冲突的问题。在定义一个类时，除了定义类的名称一般还要指定一个包名，定义包名的语法为：package 包名；

例如：

package test.Test test2;

class Point{

}

package语句必须写在java源文件的最开始，在类定义之前。

import语句 import类的全局限定名（包名+类名）；

封装的意义

1、对外提供可调用的、稳定的功能；

2、封装容易变化的、具体的实现细节，外界不可访问，这样的意义在于：

--降低代码出错的可能性，便于维护；

--当内部的实现细节改变时，只要保证对外的功能定义不变，其他的模块就不会因此而受到牵连。

public和private

1、private 自己的类里面可见其他都不可见私有的

2、private 修饰的成员变量和方法仅仅只能在本类中调用；

3、public 修饰的成员变量和方法可以在任何地方调用。

4、public 修饰的内容对外提供可以被调用的功能，需要相对稳定；

5、private 修饰的内容是对内实现封装，如果“公开”会增加维护成本。

不写修饰词默认包里可见

protected 和默认访问控制

1、用protected修饰的成员变量和方法可以被子类以及同一个包中的类使用。

2、默认访问控制即不书写任何访问控制符，默认访问控制的成员变量和方法可以被同一个包中的类调用。

public-- protected-- default-- private

protected private 可以用于修饰内部类

访问控制符修饰成员时的访问权限如下所示：

修饰符

本类

同一个包中的类

子类

其他类

public

可以访问

protected

可以访问

不能访问

默认

可以访问

不能访问

private

可以访问

不能访问

static修饰成员变量

1、用static修饰的成员变量不属于对象的数据结构；

2、static变量是属于类的变量，通常可以通过类名来引用static成员；

3、static成员变量和类的信息一起存放在方法区，而不是在堆中，一个类的static成员变量只有“一份”，无论该类创建了多少对象。

static属于类一级别所有的对象共享同一份类信息放在方法区里面

static修饰方法

1、通常的方法都会涉及到对具体对象的操作，这些方法在调用时，需要隐式的传递对象的引用（this）

int d = p1.distance（p2）；

调用distance方法是，除了传递p2参数外，还隐式传递了p1作为参数，在方法中的this关键字即表示该参数。

2、static修饰的方法则不需要针对某些对象进行操作，其运行结果仅仅与输入的参数有关，调用时直接用类名引用。

double.c=Math.sqrt(3.0*3.0+4.0*4.0);

该方法在调用时，没有隐式的传递对象引用，因此在static方法中不可以使用this关键字。

package zhangyu201776;

public class Cat {
     private int age;
     private static int numOfCats;
     Cat(int age){
          this.age=age;
          System.out.println(++numOfCats);
     }
}

package zhangyu201776;

public class CatTest {

     public static void main(String[] args){
          Cat cat1=new Cat(2);
          Cat cat2=new Cat(3);
     }
}

调用的时候直接使用类名.方法

static 静态代码块非静态代码块构造方法

static只执行一次

public class Child extends Father {
     //先加载进父类的class
     static{
          System.out.println("子类的静态代码块");
     }
     {
          System.out.println("子类的非静态代码块");
     }
     public Child(){
          //super()先调用父类的构造方法
          System.out.println("子类无参构造方法");
     }
     public Child(int i){
          this.i=i;
          System.out.println("子类有参构造方法");
     }
     public static void main(String[] args){
          Child child=new Child();
     }

public class Father {
     int i;
     static{
          System.out.println("父类的静态代码块");
     }
     {
          System.out.println("父类的非静态代码块");
     }
     public Father(){
          System.out.println("父类无参构造方法");
     }
     public Father(int i){
          this.i=i;
          System.out.println("父类有参构造方法");
     }

final

final修饰变量

final关键词修饰成员变量，意为不可改变

final 修饰成员变量，两种方式初始化：

--声明同时赋值

--构造函数初始化W

final关键词也可以修饰局部变量，使用之前要初始化

final修饰方法不能重写

final修饰类不可继承保护类不被继承修改

static final 命名常量通过名字引用的常量值

static final 修饰的成员变量称为常量必须声明同时初始化不可被改变

可以把相关的常量放到一个类中，通过类名.成员名字来访问static（静态）成员。

class Suit{
     final static int CLUBS=1;
     final static int DIAMONDS=2;
     final static int HEARTS=3;
     final static int SPADES=4;
}

会在编译时被替换

修饰词：public protected 默认的 private

static final

static 修饰会把方法提升到类的级别

final可以修饰成员变量、成员方法、类。final修饰的变量只能赋值一次。修饰的方法不能被重写，修饰的类不能被继承。

static final修饰的是静态常量

阅读全文

0 0