继承
一个标准类的写法
定义了一个类
成员变量:
成员方法:setXXX()/GetXXX()
study(),sleep()...
构造方法:
有参构造方法/无参构造方法
例如一个学生类
public class Student {
//成员变量
private String name ;//姓名
private int age ;//年龄
private String gender;//性别
//无参构造方法:
public Student() {
}
有参构造方法
public Student(String name, int age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
//SetXXX()getXXX():公共的访问方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
//学习的方法
public void study(String name) {
System.out.println(name+"...");
}
public void sleep() {
System.out.println("...");
}
测试类
public class StudentTest {
public static void main(String[] args) {
//创建学生类对象
//方式1:无参构造+setXXX()进行赋值
Student student = new Student() ;
System.out.println(student);//wesetos.org.demo1.Student@70dea4e
student.setName("哈哈");
student.setAge(27);
student.setGender("男");
System.out.println(student.getName()+"---"
+student.getAge()+"---"
+student.getGender());
//调用成员方法
student.study("刚刚");
student.sleep();
//方式2:直接有参构造进行赋值
Student student2 = new Student("诗诗", 28, "女") ;
System.out.println(student2.getName()+"---"
+student2.getAge()+"---"
+student2.getGender());
student2.study("诗诗");
student2.sleep();类的成员
1)成员变量
2)构造方法: 无参构造方法/有参构造方法
3)成员方法
//自定义一个类
class Demo{
//成员变量
private int num ;
//构造方法:方法名和类名一样,没具体的返回值并且连void都没有
//在一个类中如果没有给出无参构造方法,系统默认给定,给出了无参构造方法,系统不会默认给出了!
//构造方法的作用就是给对象进行初始化的!
//当我们开发这只要给定有参构造方法,系统不会再提供无参构造方法
public Demo() {
System.out.println("调用了无参构造方法");
}
成员方法分类
是否有返回值
有返回值类型的方法
没有返回值类型的方法,void方法
是否有参数进行划分
有参数的方法
无参数的方法
代码块
在Java语言,用{}括起来的内容,简称为代码块!
代码块的分类:
局部代码块
书写的位置,是在方法中定义的{代码...}
作用:限定变量的生命周期的
构造代码块
在类的成员位置,每次在执行构造方法之前,如果当前类中有构造代码块,优先执行构造代码块,在执行构造方法
作用:如果多个类的构造方法中有共有的内容,可以将抽取到构造代码块中
静态代码块
在类的成员位置,在{} 外面被static,静态代码块
优先于对象存在!
静态代码块只执行一次,优先执行
静态代码块>构造代码块>构造方法
//自定义类:Code
class Code{
//Code类的成员位置
//构造代码块
{
int x = 100;
System.out.println(x);
}
//无参构造方法
public Code() {
System.out.println("code...");
}
//静态代码块
static {
int x = 1000 ;
System.out.println(x);
}
//有参构造方法
public Code(int a) {
System.out.println("code...");
}
//构造代码块
{
int y = 200 ;
System.out.println(y);
}
static {
int y = 2000;
System.out.println(y);
}
}static关键字
1)在静态方法中,是没有this关键字
被静态修饰的是随着类的加载而加载,this随着对象的创建而存在
静态优先于对象存在!
被静态修饰的内容一般称为:类成员
2)访问的问题
在静态方法中,
针对成员变量:只能访问静态的成员变量
针对成员方法:只能访问静态的成员方法
在非静态方法中
成员变量:既可以访问静态成员变量,也可以访问非静态的成员变量
成员方法:既可以访问静态的成员方法,也可以访问非静态的成员方法
继承
格式:
class 子类名(派生类) extends 父类名(超类){
}
继承的好处:
1)提高代码的复用性
2)后期利于维护
3)继承关系是多态的前提
Java中的开发原则:
任何java的设计原则都要遵循当前开发原则:
低耦合,高内聚
耦合:类和类之间的关系
内聚:完成功能的执行能力
继承的特点:
在Java语言中,只支持单继承,不支持多继承
但是,可以支持多层继承!
举例
class Son extends 父类1{
}
//多继承 ,java不支持,但是其他语言有这种写法.
class Son extends 父类1,父类2...{
}
class GrandFather{
public void method() {
System.out.println("我是爷爷...");
}
}
class Father extends GrandFather{
public void show() {
System.out.println("我是爸爸...");
}
}
//class Mother{
//
//
//}
//支持单继承
class Son extends Father{
public void function() {
System.out.println("functon Son....");
}
}
//class Son extends Father,Monther{ //不支持多继承
//}
//测试类
public class ExtendsDemo {
public static void main(String[] args) {
//创建Son类对象
Son s = new Son() ;
s.function();
s.method();
s.show();
}
}
继承的注意事项:
1)子类继承父类,只能继承父类的非私有的(成员变量和成员方法)
2)子类不能继承父类的构造方法,只能通过super(等会讲)间接的去访问父类的构造方法
3)继承的使用:不要了部分功能去使用继承!
举例:
class A{
public void show(){}
public void show2(){}
}
class B{
public void show2(){}
public void show3() {}
}
直接使用继承可以了
B类改进一下
class B extends A{
public void show3() {}
}
虽然可以使用继承,但是B类虽然继承A类,拿到了show2()方法,但是同时也讲show()方法,而show()可能需要.
什么时候使用继承!
如果A类是B类的一种,这种并且能体现出是一种"is a"的关系,就使用继承!
举例:
人
学生
老师
水果
西瓜
苹果
class Fu{
private int num = 10 ;
public int num2 = 50 ;
//私有的
private void method() {
System.out.println(num);
System.out.println(num2);
}
public void function() {
System.out.println("function fu");
}
}
//子类
class Zi extends Fu{
public void show() {
// System.out.println(num);//num私有的
System.out.println(num2);
}
}
//测试类
public class ExtendsDemo2 {
public static void main(String[] args) {
Zi z = new Zi();
z.function();
// z.method() ; //私有的
System.out.println(z.num2);
// System.out.println(z.num);
z.show();
}
}
子类继承父类的时候,如果子类的成员变量名称和父类成员变量名称不一致的情况,分别输出即可!
如果子类继承父类的时候,子类中的变量名称如果和父类名称一致的情况
1)先在子类的局部位置找是否有这个变量,有,就输出
2)如果在类的局部位置找不到,再去子类的成员位置找,是否有这个变量名,有就输出
3)如果在子类的成员位置中找不到,直接就去父类的成员位置中找,有就输出
4)如果还找不到,直接报错!
class Father2{
public int num = 10 ;
/*public void method() {
int num = 200;
System.out.println(num);
}*/
}
class Son2 extends Father2{
// public int num2 = 20 ;
// int num = 20; //子类成员变量
public Son2() {
}
public void show() {
// int num = 30 ;//子类的局部变量
System.out.println(num);
// System.out.println(num2);
}
}
//测试类
public class ExtendsDemo3 {
public static void main(String[] args) {
Son2 s = new Son2() ;
s.show();
}
}子类继承父类的时候,super可以间接父类的构造方法
this:当前类的对象
super:代表父类对象(父类空间标识)
子类继承父类的时候,子类的所有的构造方法,都默认访问父类的无参构造方法
class Father3{
public Father3(){
System.out.println("这是父类的无参构造方法");
}
}
class Son3 extends Father3{
public Son3() {
//隐藏语句
super() ;
System.out.println("这是子类的无参构造");
}
public Son3(String name) {
super() ;
System.out.println("这是子类的有参构造");
}
}
public class ExtendsDemo4 {
public static void main(String[] args) {
Son3 s = new Son3(); //创建子类对象
//构造方法的作用:给对象进行初始化的
//继承关系:先让父类初始化,然后再是子类数据初始化
Son3 s2 = new Son3("hello") ;
}
}
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
