java 继承

类、父类和子类

/*
将学生和工人的共性描述提取出来，单独进行描述，
只要让学生和工人与单独描述的这个类有关系，就可以了。
继承：
1，提高了代码的复用性。
2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。
class C
{
    void demo1(){}
}
class A extends C
{
    //void demo1(){}
    void demo2(){}
}
class B extends C
{
    //void demo1(){}
    void demo3(){}
}
Java语言中：java只支持单继承，不支持多继承。
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承。也就是一个继承体系
如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
那么在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
简单一句话：查阅父类功能，创建子类对象使用功能。
class A
{
    void show()
    {
        System.out.println("a");
    }
}
class B
{
    void show()
    {
        System.out.println("b");
    }
}
class C extends A,B
{}
C c = new C();
c.show();
聚集：has a
聚合:
组合：
*/
 
class Person
{
    String name;
    int age;
}
class Student extends Person
{
        void study()
    {
        System.out.println("good study");
    }
}
 
class Worker extends Person
{
    void work()
    {
        System.out.println("good work");
    }
}
class ExtendsDemo 
{
    public static void main(String[] args) 
    {
        Student s = new Student();
        s.name = "zhagnsan";
    }
}

/*
子父类出现后，类成员的特点：
类中成员：
1，变量。
2，函数。
3，构造函数。
1,变量
如果子类中出现非私有的同名成员变量时，
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。
*/
 
class Fu 
{
    private int num = 4;
    public void setNum(int num)
    {
        this.num =num;
    }
    public int getNum()
    {
        return this.num;
    }
}
 
class Zi extends Fu
{
    //int num = 5;
    void show()
    {
        System.out.println(num);
    }
}
 
class  ExtendsDemo2
{
    public static void main(String[] args) 
    {
        Zi z = new Zi();
        z.show();
        //System.out.println(z.num+"...."+z.num);
    }
}

/*
2,子父类中的函数。
当子类出现和父类一模一样的函数时，
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。
这种情况是函数的另一个特性：重写(覆盖)
当子类继承父类，沿袭了父类的功能，到子类中，
但是子类虽具备该功能，但是功能的内容却和父类不一致，
这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。
覆盖：
1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
2，静态只能覆盖静态。
记住大家：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。
*/
 
class Fu
{
    void show()
    {
        System.out.println("fu show");
    }
    void speak()
    {
        System.out.println("vb");
    }
}
class Zi extends Fu
{
    void speak()
    {
        System.out.println("java");
    }
    void show()
    {
        System.out.println("zi show");
    }
}
class ExtendsDemo3 
{
    public static void main(String[] args) 
    {
        Zi z = new Zi();
        z.speak();
 
    }
}
class Tel
{
    void show()
    {
        System.out.println("number");
    }
    
}
class NewTel extends Tel
{
    void show()
    {
        //System.out.println("number");
        super.show();
        System.out.println("name");
        System.out.println("pic");
    }
}

/*
3，子父类中的构造函数。
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类中的构造函数。
因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定定义在子类构造函数的第一行。
子类的实例化过程。
结论：
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
*/
class Fu //extends Object
{
    int num ;
    Fu()
    {
        //super();
        num= 60;
        System.out.println("fu run");
    }
    Fu(int  x)
    {
        System.out.println("fu ...."+x);
    }
    
}
 
class Zi extends Fu
{
    Zi()
    {
        
        super();  
        //super(4);
        System.out.println("zi run");
    }
    Zi(int x)
    {
        this();
        //super();
        //super(3);
        System.out.println("zi..."+x);
    }
}
 
class  ExtendsDemo4
{
    public static void main(String[] args) 
    {
        Zi z = new Zi(0);
        System.out.println(z.num);
    }
}
 
/*
class Person
{
    private  String name;
    Person(String name)
    {
        this.name = name;
    }
    void show(){}
}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
    void method()
    {
        super.show();
    }
}
*/

Object:所有类的超类

Object中几个重要的方法：

1.equals方法：

用于检测一个对象是否等于另外一个对象，即判断两个对象是否具有相同的引用.然而对于大多数类来说这种检测没有太大意义。

在实际中用户更倾向与更具自己的标准来判断两个对象是否相等。例如：如果来年各个雇员的姓名薪水和雇佣日期都一样，就认为他们是相等的。

class Employee{
   int salary;
   String name;
   String hireday;
   //返回一个布尔值，true表示相等，否则不相等
   @Override
   public boolean equals(Object otherobject){
   //如果是同一个引用则说明相等
        if(this==otherobject) return true;
   //参数不能为空
        if(otherobject==null) return false;
   //两个对象必须同属一个类（用到了反射）
        if(this.getClass!=otherobject.getClass) return false;
   //通过上买你的判断我们知道otherobject为一个非空的Employee对象
   Employee other=(Employee)otherobject;
   //接下来实现用户自己的比较标准：雇员的姓名 薪水和雇佣日期都一样
   return    Object.equals(name,other.name)
             &&salary==other.salary
             &&Object.equals(hireday,other.hireday) 

    }
}

如果存在继承关系，则先调用父类中的equals()方法，如果父类中的检测失败（对象不相等），就说明对象不可能相等。如果检测成功则在调用子类中的检测方法。例如：

class Manager extends Employee{
   int bounds;
   //返回一个布尔值，true表示相等，否则不相等
   @Override
   public boolean equals(Object otherobject){
           if(!super.equals(otherobject)) return false;
           Maanger other=(Maanger)otherobject;
           return this.bounds==other.bounds;
    }
}

2.hashCode方法:

hash code又称为散列码，是由对象到处的一个整型值。不同的对象的散列码基本不会相同。

由于hashCode方法定义于Object类中，因此在用户没有重写此方法之前，每个对象都有一个默认的散列码，其值为对象的存储地址。
有一点需要注意：字符串的散列码是由内容导出的，String类重写了hashCode方法，如下：

class String{
 @Override
 public int hashCode(){
    int hash=0;
    for(int i=0;i<length();i++){
        hash=31*hash+charAt(i);
      }
    return hash;
  } 
}

注意：

Equals与hashCode的定义必须一致：如果x.equals(y)返回true,那么x.hashCode()就必须与y.hashCode()具有相同的值。所以通常在上面的Employee类中加上：

@Override
public int hashCode(){
  return Object.hash(name,salary,hireday);      
}

反射

概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

重要性

JAVA反射是使在运行状态中，对于任何的一个类都能知道这个类里面所以的方法，属性。对于任何一个对象都可以调用它的方法和属性。在JAVA架构中是不可缺少的一环。

反射在JAVA中的运用

package com.zking.reflection;
 
public class Peoples  {
    
    private String name;
    private String sex;
    private String id;
    
    //无参无返回
    private void a() {
        System.out.println("a");
    }
    //有参无返回
    private void b(String b) {
        System.out.println(b);
    }
    //无参有返回
    private String c() {
        return "c";
    }
    //有参有返回
    private String d(String d) {
        return d;
    }
}

建立reflect进行反射

package com.zking.reflection;
 
import java.lang.reflect.Field;
import java.lang.reflect.Method;
 
public class Reflection {
 
    private static final Class String = null;
 
    public static void main(String[] args) throws Exception {
        // 获取地址
        Class c = Peoples.class.forName("com.zking.reflection.Peoples");
        // 设置访问类型
        c.getDeclaredFields();
        //获取父類
        System.out.println(c.getSuperclass());
        
        
        //獲取接口信息
        System.out.println(c.getInterfaces());
        
        
        // 获取ID属性
        Field id = c.getDeclaredField("id");
        System.out.println(id.getName());
        
        // 获取name属性
        Field name = c.getDeclaredField("name");
        System.out.println(name.getName());
        
        // 获取SEX属性
        Field sex = c.getDeclaredField("sex");
        System.out.println(sex.getName());
        
        // 实例化对象
        Object obj = c.newInstance();
        
        // 获取名为a的方法
        Method a = c.getDeclaredMethod("a", null);
        //設置可訪問
        a.setAccessible(true);
        //調用a方法
        System.out.println(a.invoke(obj, null));
        
        
        // 获取名为b的方法
        Method b = c.getDeclaredMethod("b", String.class);//设置数据类型需与实体类方法参数类型一致
        //設置可訪問
        b.setAccessible(true);
        //調用b方法
        System.out.println(b.invoke(obj, "b"));
        
        
        // 获取名为c的方法
        Method c1 = c.getDeclaredMethod("c", null);
        //設置可訪問
        c1.setAccessible(true);
        //調用c方法
        System.out.println(c1.invoke(obj, null));
        
        
        // 获取名为d的方法
        
        Method d = c.getDeclaredMethod("d", String.class);//设置数据类型需与实体类方法参数类型一致
        //設置可訪問
        d.setAccessible(true);
        //調用d方法
        System.out.println(d.invoke(obj, "d"));
 
    }
 
}

反射常用的方法图

fanshe.jpg

枚举类

练习题

1.古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？//这是一个斐波拉契数列问题
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……。

在数学上，斐波纳契数列以如下被以递推的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从1963年起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。

public class woo {

public static void main(String args[]) {

System.out.println(fib(24));

}

private static int fib(int n) {

      if (n == 1 || n == 2) {

          return 1;

    } else {

        return fib(n - 1) + fib(n - 2);

    }

  }

}

2.判断101-200 之间有多少个素数，并输出说有素数。程序分析：判断素数的方法：用一个数分别除 2 到 sqrt（这个数），如果可以被整除，则表明此数不是素数，反之则是。

public class Prog{
    public static void main(String[] args){
        int m = 1;
        int n = 1000;
        int count = 0;
        //统计素数个数
        for(int i=m;i<n;i++){
            if(isPrime(i)){
                count++;
                System.out.print(i+" ");
                if(count%10==0){
                    System.out.println();
                }
            }
        }
        System.out.println();
        System.out.println("在"+m+"和"+n+"之间共有"+count+"个素数");
    }
    //判断素数
    private static boolean isPrime(int n){
        boolean flag = true;
        if(n==1)
          flag = false;
        else{
            for(int i=2;i<=Math.sqrt(n);i++){
            if((n%i)==0 || n==1){
                flag = false;
                break;
            }
             else
               flag = true;
          }
        }
        return flag;
    }
}

3.打印出所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如：153 是一个 “水仙花数”，因为153=1 的三次方+5的三次方+3的三次方。

public class ShuiXian {
　　public static void main(String[] args) {
    　　int a = 0;//百位数字
    　　int b = 0;//十位数字
    　　int c = 0;//个位数字
    　　int temp = 0;//百位数字立方+数位数字立方+个位数字立方
    　　for (int i = 100; i < =999; i++) {
        　　a = i/100;//计算百位数字
        　　b = (i-a*100)/10;//计算十位数字
        　　c = i%10;//计算个位数字
        　　temp = a*a*a+b*b*b+c*c*c;//相加结果
        　　if(temp==i){//判断是否相等
        　　    System.out.println(i);
        　　}
    　　}
　　}
　}

3位数其各数字立方和等于该数本身，已经限定了数字范围在100~~999之间。

最后编辑于：2019.03.23 18:47:13

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 218,036评论 6赞 506
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 93,046评论 3赞 395
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 164,411评论 0赞 354
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,622评论 1赞 293
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,661评论 6赞 392
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,521评论 1赞 304
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,288评论 3赞 418
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 39,200评论 0赞 276
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,644评论 1赞 314
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,837评论 3赞 336
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,953评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,673评论 5赞 346
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,281评论 3赞 329
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,889评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 33,011评论 1赞 269
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 48,119评论 3赞 370
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,901评论 2赞 355