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修饰的是静态常量
