继承

关键字

关键字概念：

1.就是被JAVA语言，所赋予了一些特殊意义的单词，在JAVA中，所有的关键字都是小写，如果用的是第三方的及时本，关键字会是蓝色，

2.class:class关键字是用来定义一个类的。

3. 保留关键字：目前的版本还没有使用的一些单词，可能会在后续的版本中使用。

标识符：

给类，变量 接口 常量起的名字。

命名规范：

1.可以使用字母，符号，数组组合来命名。

2.不能使用关键字来命名，会产生冲突。

3.命名时不要以数字开头（也就是不能用纯数字 数字可以在中间和结尾。）。

4.最好不要用特殊的字符来命名，但是可以使用美元符号和下划线来命名。

5.命名最好见名知意。

6.区分大小写

以上是通用的命名规范 比如给类命名，要求首字母大写，可以采用驼峰式命名。（StudentName)

​

static关键字

static 静态的 可以修饰成员变量和成员方法，此变量为一个共享变量，会被这个类的所有对象所共享。

特点：

1.随着类的加载而加载。随着类的卸载而卸载

2.所修饰的成员是优先于对象而存在的。

3.被类的所有对象所共享。

4.被静态所修饰属于类 不属于对象，建议使用类名直接调用，

person.country = "美国“//类.对象 = 属性
person.country();//直接调用

static关键字的注意事项

1，在静态方法里面不能调用非静态的方法。也就是静态方法只能访问静态所修饰的成员。后有的一定能访问到先有的。（非静态方法中即可以访问非静态的成员 ，也可以访问静态成员）,

2.在静态方法中不能存在this关键字。this本身代表的是该类的对象，对象是后来才有的。

在test中一般不定义成员变量和成员方法。

静态变量和成员变量的区别：

1.静态变量属于类，所以也称为类变量，

成员变量属于成员变量，也成为实例变量或对象变量。

2.静态变量存在方法区的静态区

成员变量存在堆内存。

3.静态变量随着类的加载而加载，随着类的消失而消失。

成员变量：随着对象的创建而存在，随着对象的消失而消失。

静态变量存在方法区的静态区。

4.静态变量可以通过类名调用，也可以通过对象调用，不过推荐使用类名调用。

成员变量只能通过对象名调用。

java提供的Math类

该类包含用于执行基本数学的运算的方法。

Math类存在java.lang包下面，所以不需要导包。没有构造方法，因为他的成员全部都是静态的。

java提供的Math类
Math.random();//生成一个随机小数
int v = (int) (Math.random() *100) +1/数

猜数字小游戏：

package com.itheima.demo1;

import java.util.Scanner;

public class test1 {
    public static void main(String[] args) {
//给用户10次机会，每猜一次，提示剩余次数
        //猜数字小游戏
        int num = (int) (Math.random() * 100 + 1);
        while (true){
            for(int i=9;i>=0;i--){
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入一个1-100的整数");
                int usernum = sc.nextInt();
                if (usernum > num) {
                    System.out.println("你猜大了");
                } else if (usernum < num) {
                    System.out.println("你猜小了");
                } else {
                    System.out.println("恭喜你第猜对了");
                    break;
                }


                System.out.println("剩余"+i+"次");
            }
            break;
        }
        System.out.println("游戏结束");
    }
}

代码块

被一对大括号括起来的

{代码块}

局部代码块：定义在方法中的代码块。限定变量声明周期。

构造代码块：定义在类中方法外的代码块。在创建对象时，构造代码块会执行，而且优先于构造方法执行。

静态代码块：给构造代码块加一个static，静态代码块最早执行，而且只执行一次。因为类只加载一次，只能访问被静态所修饰的成员。经常会在静态代码块里面做一些初始化的准备工作。

同步代码块

测试类：带有入口 先加载。

继承：

子类可以继承父类中的成员。（成员变量和成员方法）

extence关键字

class zi extends fu

继承的好处：可以提高代码的复用性。维护性，让类和类之间产生了关系，是多肽的前提。

弊端：让类和类之间产生了关系，增加了耦合性

程序的设计原则：高内聚，（一个类 独立完成某个功能的能力）

低耦合：（类和类之间的关系，依赖关系）

继承的特点：只支持单继承，一个子类只能有一个父类，但是支持多层继承

继承的注意事项：

1.子类只能继承父类非私有的成员，（成员变量和成员方法）

2.构造方法不参与继承。也就是子类不能继承父类的构造方法，当时可以通过supper关键字去访问父类的构造方法。

3.不要为了部分功能去继承。

继承中成员变量的关系：

如果子类中的成员变量和父类中的成员变量和父类中的成员变量一样：

在子类中访问一个变量的查找顺序 ：

我们采用就近原则。

先在局部变量范围中查找，如果没找到就去该类的成员变量中找，如果还没找到 就去父类的成员范围中找。如果好没有找到就报错。

super关键字：

继承的思想：

继承就是把多个子类的共性部分向上抽取到父类中，来实现代码的复用性和维护性。

用this来区分局部变量和成员变量。

this h和super的区别：

this:代表的是本类对象的引用，

super:代表的是父类存储空间的标识（可以理解成父类的引用，可以操作父类的成员）

super关键字：

supse：代表父类的空间的一个标识符，

super():访问父类的空参构造。

调用成员变量

super.成员变量  访问父类的成员变量。
this.成员变量   调用本类的成员变量
this（）调用本类空参

调用构造方法
this(...)  调用本类的构造方法
supper(....)  调用父类的构造方法

调用成员方法
this.成员方法   调用本类的成员方法
supper.成员方法    调用父类的成员方法

this和super不能同时存在在构造方法里面

在每个类的构造方法中的第一行有一行默认语句是super()会去构造父类的空参调用，

java继承体系中的顶层父类是object，所有类 都是直接或者间接继承自它。

如果父类没有空参构造，

想办法调用父类有参构造，super(调用的有参构造数据)

1.在父类中添加一个无参的构造方法，

2.子类通过super()去显示调用父类其他的代参的构造方法。

3.子类通过this调用本类的其他构造方法。 本类的其他构造也必须先访问了父类构造。

//因为子类要继承使用父类的数据,所以在初始化子类的时候 先要调用父类的构造方法，来完成父类数据的初始化，这样才能继承父类的数据。
class Fu {
		static {
			System.out.println("静态代码块Fu");//1 
		}

		{
			System.out.println("构造代码块Fu"); //3
		}

		public Fu() {
			System.out.println("构造方法Fu"); //4
		}
	}

	class Zi extends Fu {
		static {
			System.out.println("静态代码块Zi");//2
		}

		{
			System.out.println("构造代码块Zi"); //5
		}

		public Zi() {
			super();
			System.out.println("构造方法Zi"); //6
		}
	}
	
	class Test{
		public static void main(String[] args){
			Zi z = new Zi(); //请执行结果。
		}
		

方法重写：

方法声明（方法名，方法参数，返回值类型）。一样也就是方法一模一样，子类的方法会覆盖父类的方法。这个叫做方法重启。

方法重写：写法一模一样，输出自己想要的内容就可以了。

@Override   重写父类的注解，用来检测这个方法是不是重写父类的  写在要重写的子类那里。，ctr+o  重写父类方法

在原来call功能基础上进行扩展
super.call();//将父类打电话的功能保留
再扩展自己的功能（）//写法同上

定义一个手机类。
通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。

//父类
package com.itheima.demo;

public class phone {
    public void call(){
        System.out.println("打电话");
    }
}
//子类
package com.itheima.demo;

public class newphone extends phone {
    @Override
    public void call() {
        super.call();
        System.out.println("听天气预报");
    }
}
//测试类
package com.itheima.demo;

public class test {
    public static void main(String[] args) {
        newphone np = new newphone();
        np.call();

    }
}

重写的注意事项：

1.父类私有的方法不能重写。因为私有方法都不能继承。

2.构造方法不参与重写。

3.子类在重写父类方法时，方法的权限修饰符不能比父类的方法低

， 要么跟父类方法的权限一样。

public>protected>缺省>private

4.静态方法不参与重写。

final关键字

由于继承中有一个方法重写的现象，而有的时候我们不想让子类去重写父类的方法，这种情况下使用final关键字。

可以修饰变量：此变量可以变为一个常量

final int NUM = 200;//自定义常量，常量名一般大写。

public static final int B = 2000 //公共的静态常量
final修饰方法，此方法不能被重写。只能继承
final 修饰类，此类不能被继承。
final修饰基本类型 指这个指不能再次改变，final修饰引用类型，指这个地址值不能再次被改变。