文档章节

Java基础之继承

克温s
 克温s
发布于 2015/11/12 20:42
字数 2696
阅读 9
收藏 0

1,利用继承,人们可以基于已存在的类构造一个新类。继承已存在的类就是复用(继承)这些类的方法和域。在此基础上添加一些新的方法和域,以满足新的需求(is-a)。

2,反射是指程序运行期间发现更多的类及其属性的能力。

3,overload重载,override覆盖

4,super关键字与this关键字区别:

    1)this关键字相当于对象的引用;

    2)super不是引用,不能将super赋给一个对象变量,它只是一个指示编译器调用超类方法的特殊关键字;

    3)this一是引用隐式参数,二是调用该类的其它构造器;

    4)super一是调用超类方法,二是调用超类的构造器。

5,子类中可以增加数据域、方法,或覆盖父类的方法,但是不能删了继续的数据域或方法;

6,子类构造器可以使用super()显示调用父类的构造器,如果子类不显示调用,则子类会默认调用父类的无参构造器;

如果子类没有显示的调用父类的构造,但父类又没有默认、无参构造,则编译器会报错。

7,一个对象变量(如e)可以指示多种实际类型的现象被称为多态,在运行时能够自己动地选择调用哪个方法的现象称为动态绑定。

public class Test {
    public static void main(String[] args) {
        Manager boss = new Manager("test", 8000, new Date());
        boss.setBonus(5000);

        Employee[] staff = new Employee[3];
        staff[0] = boss;
        staff[1] = new Employee("test1", 7000, new Date());
        staff[2] = new Employee("test2", 6000, new Date());

        for (Employee e : staff) {
            System.out.println(e.getName() + "  " + e.getSalary());
        }
    }
}
public class Employee {

    private String name;

    private double salary;

    private Date hireDay;

    public Employee() {

    }

    public Employee(String name, double salary, Date hireDay) {
        this.name = name;
        this.salary = salary;
        this.hireDay = hireDay;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Date getHireDay() {
        return hireDay;
    }

    public void setHireDay(Date hireDay) {
        this.hireDay = hireDay;
    }
}
public class Manager extends Employee {

    private double bonus;

    public Manager() {

    }

    public Manager(String name, double salary, Date hireDay) {
        //初始化父类的构造,必须放在第一句
        super(name, salary, hireDay);
        this.bonus = 0;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public double getSalary() {
        //super.getSalary() 调用父类的方法,只有Employee中的方法才能够访问其数据域
        return bonus + super.getSalary();
    }
}

8,对象变量是多态的,每个对象变量都属于一个类型;

9,动态绑定:

    1)x.f(param),x为C类的对象,首先编译器会获得所有C类对象(即C类的父类、子类)所有public修饰的f()方法;

    2)编译器查看调用方法的参数类型,如String类型参数,hello('test'),如果在父类或子类中存在多个类型相同的方法,编译器会报错,至此编译器与获得所有方法名和参数类型;

    3)如果是static,private,final方法,编译器准确的知道调用哪个方法,这叫“静态绑定”;与之相对的是动态绑定;

    4)程序运行时JVM一定调用与x所引用对象类型最合适的那类的方法,假设x的实际类型是D,D是C的子类,所以JVM会调用D的f()方法;

    5)JVM每次运行时去会进行搜索,时间开销相当大,所以会建以一个方法表,需要时从方法表中读取。

10,子类覆盖父类方法时,访问权限不能低于父类的访问权限,如父类是public,子类也必须是public;反之编辑器会把它解释为试图降低访问权限;

11,阻止继承,final类、方法;

    1)final类不允许被继承;如果类被声明为final,其类中的方法自动的转为final方法(不允许类继承,所以方法也是不能继承的),例如:String是final类,不允许继续;其作用主要是确保子类不会改变其语义。

    2)final方法,子类不允许覆盖;

    3)fina域,构造初始化对象过后不再允许更改它的值。

12,早期java中使用final关键字来避免动态绑定,如果一个方法较短并且没有被覆盖,编译器就会对其进行内联优化,例如:e.getNmae()将被优化成e.name;目前JVM的即时编译器比传统编译器处理能力强得多,可以对那些较短的方法,调用频率高的类进行自动优化,如果后期继承的子类对优化的方法有覆盖,优化器将取消内联优化,这个过程很慢,但很少发生。

13,类型转换,使用is-a原则,子类可以强制转换为基类,反之不行;ClassCastException

if(staff[1] instanceof Manager){
    boss = (Manager)staff[1];
}

14,包含一个或多个抽象方法的类必须被声明为抽象类;抽象类同时包括具体数据和具体的方法;

abstract class Person{
    private String name;
    
    public abstract String getDescription();
    
    public Person(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
}

15,类不包含抽象方法也可以声明为抽象,抽象类不可以被实例化。但可以定义抽象类的对象变量:

class Student extends Person{
}

//Pserson为抽象类,student为实现的子类
Person p = new Student("test", "test");
public abstract class Person {
    private String name;

    public abstract String getDescription();

    public Person(String name) {
        System.out.println("Person构造");
        this.name = name;
    }

    public String getName() {
        return name;
    }

}
public class Student extends Person {

    private String major;
    
    //父类中存在有参构造,子类一定要先调用父类构造,如果是默认的,可以不调用super
    public Student(String name, String major) {
        super(name);
        System.out.println("Student构造");
        this.major = major;
    }

    @Override
    public String getDescription() {
        return "a student major in " + major;
    }

}
public class Employee extends Person {

    private double salary;
    private Date   hireDay;

    public Employee(String name, double salary, Date hireDay) {
        super(name);
        System.out.println("Employee构造");
        this.salary = salary;
        this.hireDay = hireDay;
    }

    @Override
    public String getDescription() {
        return String.format("an example with a salary of $%.2f", salary);
    }

    public double getSalary() {
        return salary;
    }

    public void raiseSalary(double byPercent) {
        double raise = salary * byPercent / 100;
        salary += raise;
    }
}
public static void main(String[] args) {
        Person[] persons = new Person[2];
        persons[0] = new Student("student", "class");
        persons[1] = new Employee("emplyee", 9000, new Date());
        for (Person person : persons) {
            System.out.println(person.getName() + ", " + person.getDescription());
        }
    }
输出结果:
Person构造
Student构造
Person构造
Employee构造
student, a student major in class
emplyee, an example with a salary of $9000.00

16,子类同样无法访问父类的private域;

17,protected方法比protected域更有实际意义,可以让子类调用父类的方法,其它包外的类不允许;

18,protected与defalut的区别:

    1)protected,子类、包内访问权限,但这里有一点需要注意:如果子类在包外,也是可以访问的;

    2)default,包内访问权限,没有子类这种定义,相当于只能在包内才能访问,只要在包外都不可以访问;

19,访问权限从大到小的顺序:

    public->protected->default->private

20,Object类是java所有类的超类,java中的每个类都是由object类扩展而来,如果没有明确指出超类,Object就是这个类的超类;

 //object只能持有引用,不能对内容进行操作
Object obj = new Employee("", "");

21,在java中只有基本类型不是对对象,例如:数值,字符,布尔型的值都不是对象,8种基本数据类型;

22,Object的equals比较的是两个对象引用是否相等

23,==比较基本数据类型, equals比较对象域(数据),如果都相等,则返回true;

24,hashcode,散列码,是由对象导出的一个整型值,两个对象的.hashCode()基本不会相同;

25,由于hashCode方法定义在Object类中,因此每个对象都有一个默认的hashcode,其值为对象的存储地址

26,

        String s = "OK";
        StringBuilder sb = new StringBuilder(s);
        System.out.println(s.hashCode() + " " + sb.hashCode());
        String t = new String("OK");
        StringBuilder tb = new StringBuilder(t);
        System.out.println(t.hashCode() + " " + tb.hashCode());
        
        结果:
        2524 14576877
        2524 12677476

    为什么s、t的散列码相同?因为String重写了Object的hashcode,导出内容的散列码;

    然而sb、tb的散列码不同?因为StringBuilder没有重写Object的hashcode,采用了Object的默认方法,导出的是对象的存储地址。

27,equals与hashCode的定义必须一致:如果x.equals(y)返回true,那个x.hashCode()必须与y.hashCode()具有相同的值(存储地址);

    Arrays.hashCode();     

    hashCode(null) = 0,hashcode可以为正数或负数;

28,toString(对对象来说x.toString()与""+x是等价的,但如果x是基本类型则会直接执行)

    @Override
    public String toString() {
        return super.toString() + "Employee[name=" + super.getName() + ", salary=" + salary
               + ", hireDay=" + hireDay + "]";
    }

29,toString打印数组

        int[] array = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(array));
        //打印多维数组
        Arrays.deepToString();

30,ArrayList动态数组,在数组已满的情况下,会重新创建一个更大的数组,然后将较小的数组copy到较大的数组中;

    1)数组列表管理着对象引用的一个内部数组;

    2)JAVA7中,如果确定一个数组列表容量,可以提前分配数组的列表容量arraylist.ensureCapacity(100);同时也可以采用以下方式:

List<String> arrayList = new ArrayList<String>(100);

    3)数组列表容量与数组大小有区别(new Employee[100]),分100个空间,说明数组有100个空位置可用;100个列表容量表示只是拥有保存100个元素的潜力,实际上,重新分配空间的话会超过100;

31,ArrayList与数组区别:

    1)数组,固定长度,效率较ArrayList高;

    2)ArrayList,动态数组,可变长度,无初始化数组长度,底层当然是用数组来实现;

    3)ArrayList由于增加了灵活性,所以较数组效率低;

        List<String> arrayList = new ArrayList<String>(100);
        for (int i = 0; i < 20; i++) {
            arrayList.add(String.valueOf(i));
        }
        //数组
        String[] arrays = new String[arrayList.size()];
        //转换为数组
        arrayList.toArray(arrays);
        System.out.println(Arrays.toString(arrays));
        输出结果:
        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

32,每个基本数据类型都有一个包装器类,如:Integer,Long,Float,Double,Short,Byte,Void,Boolean,其中前6个派生于公共的超类Number。

    1)Integer.valueOf(int),自动装箱

    2)list.get(i).intValue(),自动拆箱

    3)装箱和拆箱是编译器认可的,不是JVM

33,继承设计:

    1)将公共操作、域放在超类;

    2)不要使用受保护的域;protected,破坏封装,无限子类可以访问;同一个包中可以访问导致不是子类也可以访问;但需要在子类中重新定义的可以使用;

    3)使用继承实现“is-a”关系,继承很容易达到节省代码的目的;

    4)除非所有的继承方法都有意义,否则不要继承;

    5)在覆盖方法时,不要改变预期的行为;置换原则不仅应用于语法,而且也可以应用于行为;

    6)使用多态,而非类型信息(根据类型来判断使用哪个方法);

    7)不要过多的使用反射。反射是很脆弱的,编译器很难发现程序中的错误,只有在运行时发现,并导致错误或异常。


© 著作权归作者所有

共有 人打赏支持
克温s
粉丝 2
博文 52
码字总数 19221
作品 0
东城
项目经理
私信 提问
Java培训实战教程之Java基础知识精华部分(四)(五)

Java培训实战教程之Java基础知识精华部分(四)_设计模式 =============================================================================Java培训实战教程之Java基础知识精华部分(四)_设计模...

黑泽明军
2018/04/13
0
0
简单的入门Android开发和Java语言基础[图]

简单的入门Android开发和Java语言基础[图] 前言: 去年年底到今年年初,我做过简单的智能家居,也实现过一些简单的直连和远程的智能家居。于是就将最简单的通信发布出来:智能家居简单实现—...

原创小博客
2018/08/04
0
0
Java程序员从笨鸟到菜鸟全部博客目录【2012年十一月七日更新】

本文来自:曹胜欢博客专栏。转载请注明出处:http://blog.csdn.net/csh624366188 大学上了一年半,接触java也一年半了,虽然中间也有其他东西的学习,但是还是以java为主路线,想想这一年半,...

长平狐
2012/11/12
103
0
了解一下Java 8 (一)

2015年公司发展迅速,于是大量的时间花费在招聘上。招聘工程师,必然需要了解候选人的技术能力,尤其是对自己使用的技术的了解程度。优秀的工程师都需要知其然,也知其所以然,否则遇到技术难...

TalkingData
2016/01/20
1K
8
《Java程序员由笨鸟到菜鸟》电子版书正式发布,欢迎大家下载

在众多朋友的支持和鼓励下,《Java程序员由菜鸟到笨鸟》电子版终于和大家见面了。本电子书涵盖了从java基础到javaweb开放框架的大部分内容。在编写的过程中,难免会出现一些错误,希望大家能...

长平狐
2012/11/12
128
0

没有更多内容

加载失败,请刷新页面

加载更多

Mysql(Mariadb)数据库主从复制

Mysql主从复制的实现原理图大致如下: MySQL之间数据复制的基础是以二进制日志文件(binary log file)来实现的,一台MySQL数据库一旦启用二进制日志后,其作为master,它数据库中所有操作都...

linux-tao
52分钟前
2
0
Mysql(Mariadb)数据库主从复制

Mysql主从复制的实现原理图大致如下: MySQL之间数据复制的基础是以二进制日志文件(binary log file)来实现的,一台MySQL数据库一旦启用二进制日志后,其作为master,它数据库中所有操作都...

Linux就该这么学
今天
2
0
Mysql(Mariadb)数据库主从复制

Mysql主从复制的实现原理图大致如下: MySQL之间数据复制的基础是以二进制日志文件(binary log file)来实现的,一台MySQL数据库一旦启用二进制日志后,其作为master,它数据库中所有操作都...

xiangyunyan
今天
2
0
Android 自定义Path贝塞尔曲线View实践——旋转的花朵

一、关于贝塞尔曲线 在工业设计方面贝塞尔曲线有很多用途,同样,在Android中,贝塞尔曲线结合Path类可以实现更复杂的图形,这里我们给一个案例,来实现一种旋转的花朵。对于贝赛尔曲线的理解...

IamOkay
今天
3
0
7、redis主从复制和sentinel配置高可用

一:redis主从配置 1、环境准备 master : 192.168.50.10 6179 slave1: 192.168.50.10 6279 slave2: 192.168.50.10 6379 2、redis.conf配置文件配置 master port 6179......

刘付kin
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部