一、继承
概念:继承时面向对象最显著的一个特性,继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力。
Java继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,但不能选择性的继承父类、超类、基类。
这种技术使得复用以前的代码非常容易,能够大大缩短开发周期,降低开发费用。
1.初衷:本质上就是想要提高代码的复用性,减少代码的编写
2.解决方案:把所有的共性代码向上抽取,形成父类
3.特点
1)使用extends关键字
2)向单一把父类的功能复制了一份
3)java只支持单继承
4)继承可以传递(爷爷-儿子-孙子的关系)
5)不能继承父类的私有成员
6)继承多用于功能的修改,子类可以拥有父类的功能的同事,进行功能扩展
6)像是is a的关系
**4.入门案例:**
//这个类用来测试 继承的 入门案例
public class Test1_Extends {
public static void main(String[] args) {
//创建父类对象测试
Father f = new Father(); f.sleep();
f.eat();
System.out.println( f.skin );
System.out.println( f.country );
//3、 创建子类对象测试
Son s = new Son();
//直接使用了爸爸类的功能!!
s.eat();
System.out.println( s.skin );
System.out.println( s.country );
// System.out.println(s.sifangmoney);//5.1、是父类的私有成员,子类看不见更用不了
//直接使用了爷爷类的功能!!
s.sleep();
}
}
//7、继承可以传递
class Yeye{
public void sleep() {
System.out.println("Yeye...sleep()");
}
}
//创建父类
class Father extends Yeye {
//5、父类的私有成员 子类 无法 继承
private double sifangmoney = 100 ;
String skin ="黄种人" ;
String country = "中国";
public void eat() {
System.out.println("Father...eat()");
}
}
//1、创建子类,通过extends关键字表示继承
//4、java只支持单继承
class Son extends Father{//6、继承的关系是is a的关系,强制要求子类必须 继承父类,否则一无所有 -- 强耦合性!!
//2、相当于子类把父类的功能 通通复制过来了
}
二、super关键字和this的对比使用
package com.xsd.oop;
//这个类用来测试 继承的使用
public class Test2_UseExtends {
public static void main(String[] args) {
//创建对象测试
Zi zi = new Zi();
zi.show();
}
}
//创建父类
class Fu{
int sum = 10 ;
int count = 30 ;
}
//创建子类
class Zi extends Fu{
int count = 20 ;
public void show() {
int count = 10 ;
System.out.println(count);//10 ,使用了局部变量
System.out.println( this.count ); //20,使用了成员变量。当成员变量和局部变量同名时,想用成员变量就通过this调用
//1、想要在子类中,使用父类的sum -- 可以直接用!
System.out.println( super.sum );
//2、想要在子类中,使用父类的count -- 由于已经和子类的变量名同名了,如果想用父类的,必须super
//3、super关键字,用来表示父类对象的引用。可以在子类中使用父类功能。
System.out.println( super.count );//30,使用了父类变量
}
}
三、方法重写override
1.是发生在继承结构中
2.在需要修改原有功能时,才在子类中发生方法重写。
3.要求:子类的方法声明、签名和父类一模一样
四、继承的使用
1、成员变量
package com.xsd.oop;
//这个类用来测试 继承的使用
public class Test2_UseExtends {
public static void main(String[] args) {
//创建对象测试
Zi zi = new Zi();
zi.show();
}
}
//创建父类
class Fu{
int sum = 10 ;
int count = 30 ;
}
//创建子类
class Zi extends Fu{
int count = 20 ;
public void show() {
int count = 10 ;
System.out.println(count);//10 ,使用了局部变量
System.out.println( this.count ); //20,使用了成员变量。当成员变量和局部变量同名时,想用成员变量就通过this调用
//1、想要在子类中,使用父类的sum -- 可以直接用!
System.out.println( super.sum );
//2、想要在子类中,使用父类的count -- 由于已经和子类的变量名同名了,如果想用父类的,必须super
//3、super关键字,用来表示父类对象的引用。可以在子类中使用父类功能。
System.out.println( super.count );//30,使用了父类变量
}
}
**2、成员方法**
package com.xsd.oop;
//这个类用来测试 继承的 方法使用
public class Test3_UseExtends {
public static void main(String[] args) {
//创建对象测试
Zi2 zi = new Zi2();
zi.eat();//1、重写前,使用了 从父类的方法体 。 重写后,使用了子类的方法体
zi.study(); //3、使用了 子类 自己特有的方法
}
}
//创建父类
class Fu2{
public void eat() {
System.out.println("爸爸在吃猪肉");
}
}
//创建子类
class Zi2 extends Fu2{
//4、由于子类的实现方式 和 父类不一样,所以我们可能会 需要修改 原来的功能 -- 方法重写!!!
//5、重写要求: 子类 的 方法声明 和父类一样
//6、在工作中,不要擅自打开源代码直接进行修改,可能会引发很多bug。最好继承后重写!!重写并没有影响原有功能!!!
public void eat() { // 方法声明一样
// super.eat(); //7、在子类中,使用父类的功能--想看看对父类的功能有没有影响 -- 没有影响
System.out.println("儿子在喝汤");
}
//2、子类 除了可以继承父类的方法,还可以自己扩展方法
public void study() {
System.out.println("我爱java");
}
}
3、构造方法
package com.xsd.oop;
//这个类用来测试 继承的 方构造法使用
public class Test4_UseExtends {
public static void main(String[] args) {
//创建对象测试
Zi3 zi = new Zi3() ;
}
}
//创建父类
class Fu3{
// public Fu3( ) { } // 3、建议,无参构造方法 随时提供
public Fu3(int a) {
System.out.println("父类 构造方法");
}
}
//创建子类
class Zi3 extends Fu3{
// public Fu3( ) { } // 5、构造方法不能被继承!!语法就不对!!
public Zi3() {
//1、子类的无参构造中,默认就存在super(),自动找父类的 无参构造
// super() ;
//2、如果,父类中,根本不存在无参构造了 --只能调用父类 的 含参构造
super(100) ;
//4、super关键字使用 在 构造方法里 时,必须是一条语句!!!神似this
System.out.println("子类 构造方法");
}
}
五、static关键字
1、特点
--可以修饰成员变量,成员方法
--随着类的加载而加载,优先于对象加载
--只加载一次,就会一直存在,不再开辟新空间
--全局唯一,全局共享
--可以直接被类名调用
--静态只能调用静态,非静态可以随意调用
--static不能和this或者super共用,因为有static时可能还没有对象
--2、入门案例
package com.xsd.staticdemo;
//这个类用来测试 静态
public class Test5_Static {
public static void main(String[] args) {
//2、静态资源 建议 使用静态方式访问:直接被类名调用
//3、静态资源 优先于 对象加载。没有对象时,静态资源也会第一时间加载进内存。
Person.study();
//创建对象测试
Person p = new Person();
p.name = "熊大";
p.study();
p.coding();
System.out.println( p.name );
System.out.println( p.age );
//4、静态资源 是共享资源 。在多个对象间可以共享。
Person p1 = new Person();
System.out.println( p1.name );//熊大
//5、static不能和this或者super共用,因为加载static时可能还没有对象呢
}
}
//创建Person类
class Person{
//提供普通的 成员变量 成员方法
//1、static 可以修饰成员变量 或者 成员方法
static String name ;
int age ;
static public void study() {
System.out.println("正在学习java");
}
public void coding() {
System.out.println("正在敲代码");
}
}
3、调用关系
package com.xsd.staticdemo;
//这个类用来测试 静态 的调用
//总结1: 普通资源怎么调用都可以。 静态资源 只能 调用静态资源。
public class Test6_Static {
public static void main(String[] args) {
//创建对象测试
Person2 p = new Person2(); p.eat();
}
}
//创建Person2类
class Person2{
//1、普通资源 能不能 调用 静态资源 ? --- 可以!!
String name;
public void eat() {
game();
System.out.println( age );
}
//2、静态资源 能不能 调用 普通资源 ? --- 不可以,静态只能调静态
static int age ;
static public void game() {
// System.out.println( name );
}
}
六、代码块
1.静态代码块:随着类的加载而加载,并且只被加载一次,一般用于项目的初始化
2.静态代码块:位置在成员位置+作用用来只加载一次并且加载的早
3.语法:static{代码…}
4.测试:静态代码块 构造代码块 局部代码块
package com.xsd.block;
//这类用来 测试代码块
//TODO 总结:作用 + 触发节点
public class Test7_Block {
public static void main(String[] args) {
// 测试
Student s = new Student();
s.show();
Student s2 = new Student();
}
}
//创建Student类
class Student{
//1、提供静态代码块:位置是在成员位置 + 只会加载一次 + 加载的早
static {
System.out.println("静态 代码块");
}
//提供构造代码块:位置是在成员位置
{
System.out.println("构造 代码块 ");
}
//提供构造方法
public Student() {
System.out.println("构造方法");
}
//提供局部代码块
public void show() {
{
System.out.println("局部 代码块");
}
}
}