ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

复习,final关键字,抽象类,抽象类的练习以及不能与指定关键字一起使用

2022-01-15 02:02:12  阅读:21  来源: 互联网

标签:name void public 关键字 static 抽象类 final 构造函数



static(静态、修饰符)

static修饰成员变量: 如果一个成员变量使用static修饰,那么该成员变量的数据就是一个共享 的数据.,、

静态成员变量的访问方式

方式一:可以使用对象访问。
对象.属性名
方式二:可以使用类名访问。
类名.属性名

注意:
1. 非静态成员变量不能使用类名直接访问,要使用对象访问.
2. 千万不要为了访问方便而使用static修饰。一定要数据真正是需要被共享的时候才使用static修饰。

static修饰成员函数:

静态函数的访问方式
方式一:可以使用对象访问。
对象.属性名
方式二:可以使用类名访问。
类名.属性名

推荐使用类名访问静态的成员。

静态函数要注意的细节:
1. 非静态函数只能由对象调用,静态函数可以由类名或者对象进行调用。
2. 静态函数中不能直接访问非静态成员,可以直接访问静态的成员。
3. 非静态函数可以直接访问非静态成员以及可以直接访问静态的成员。
4. 静态函数中不能出现this或者super关键字。

单例设计模式:保证一个类在内存中只有一个对象。

饿汉单例设计模式:
1. 私有化构造函数。
2. 声明本类的引用类型变量并且指向本类的对象,(private static)
3. 提供一个公共静态的方法获取本类对象。

懒汉单例设计模式:
1. 私有化构造函数。
2. 声明本类的引用类型变量,但是不要创建对象。
3. 提供一个公共静态的方法获取本类对象,获取之前先判断是否已经创建了本类的对象,
如果没有创建,创建再返回。如果已经创建了,那么直接访问即可。

继承:


继承的格式:

class 类名1 extends 类名2{

}

继承要注意的事项:
1. 父类私有的成员不能被继承。
2. 父类的构造函数不能被继承。
3. 创建子类对象时,默认会先调用父类的无参构造函数,然后再调用子类 的构造函数。


super关键字:super关键字代表的是父类的引用空间。


super关键字的作用:
1. 如果子父类存在同名的成员时,在子类中默认是访问子类的成员,可以通过super关键字指定访问 父类的成员。
2. 创建子类对象时,默认会先调用父类的无参构造函数,可以通过super关键字指定调用父类的构造函数,


super关键字要注意的事项:
1. 如果在子类 的构造函数中没有指定调用具体父类构造函数,那么java编译器会在子类的构造函数上添加super()语句。
2. super关键字调用构造函数时必须出现构造函数中第一个语句。
3. this与super调用构造函数的时候不能同时出现在一个构造函数中,因为都需要是第一个语句。


方法重写:子父类存在着同名的函数。

方法重写的需求: 如果父类的功能无法满足子类的需求,那么就进行重写。


方法重写的要素:
1. 函数名与形参列表必须一致。
2. 子类的权限修饰符必须大于或者等于父类 的权限 修饰符。
3. 子父类的返回值类型必须小于或者等于父类的返回值类型。
4. 子类抛出的异常类型必须要小于或者等于父类抛出的异常类型。


instanceof:判断一个对象是否属于某种类型。

instanceof关键字的使用格式:

对象 instanceof 类。

instanceof的使用前提:判断的对象与类型必须存在继承或者实现的关系。

 

final(最终、修饰符)

final关键字分析:

 

 



final关键字的用法:
1. final关键字修饰一个基本类型的变量时,该变量不能重新赋值,第一次的值为最终的。
2. fianl关键字修饰一个引用类型变量时,该变量不能重新指向新的对象。
3. final关键字修饰一个函数的时候,该函数不能被重写。
4. final关键字修饰一个类的时候,该类不能被继承。


常量 的修饰符一般为: public static final

代码演示:

//圆形
class Circle{

double r; //半径

public static final double pi = 3.14; //固定不变的

public Circle(double r){
this.r = r;
}

//计算面积
public final void getArea(){
System.out.println("圆形的面积是:"+r*r*pi);
}
}



class Demo27 extends Circle
{

public Demo27(double r){
super(r);
}

public static void main(String[] args)
{
/*
final Circle c = new Circle(4.0);
test(c);
*/
Demo27 c = new Demo27(4.0);
c.getArea();
}



public static void test(Circle c){
c = new Circle(5.0); //c变量又重新指向了新的对象。
c.getArea();
}

}
运行结果:

 

 

抽象类:

目前存在的问题:
1. 动物类的run方法描述的不正确。
2. 没有强制要子类一定要重写run方法。

抽象类的应用场景:
我们在描述一类事物的时候,发现该种事物确实存在着某种行为,
但是这种行为目前是不具体的,那么我们可以抽取这种行为 的声明,但是
不去实现该种行为,这时候这种行为我们称作为抽象的行为,我们就需要使用抽象类。

抽象类的好处: 强制要求子类一定要实现指定的方法。


抽象类要注意的细节:
1. 如果一个函数没有方法体,那么该函数必须要使用abstract修饰,把该函数修饰成抽象 的函数。。
2. 如果一个类出现了抽象的函数,那么该类也必须 使用abstract修饰。
3. 如果一个非抽象类继承了抽象类,那么必须要把抽象类的所有抽象方法全部实现。
4. 抽象类可以存在非抽象方法,也可以存在抽象的方法.
5. 抽象类可以不存在抽象方法的。
5. 抽象类是不能创建对象的。
疑问:为什么抽象类不能创建对象呢?
因为抽象类是存在抽象方法的,如果能让抽象类创建对象的话,那么使用抽象的对象
调用抽象方法是没有任何意义的。
6. 抽象类是存在构造函数的,其构造函数是提供给子类创建对象的时候初始化父类的属性的。

代码演示:

//动物类--->抽象类
abstract class Animal2{

String name;

String color;

public Animal2(String name,String color){
this.name = name;
this.color = color;
}


//非抽象的方法
public void eat(){
System.out.println(name+"吃粮食");
}

//移动...
public abstract void run();
}



//狗 是属于动物中一种
class Dog extends Animal2{

public Dog(String name,String color){
super(name,color);
}

public void run(){
System.out.println(name+"四条腿跑得很快...");
}
}


//鱼 是属于动物中一种
class fish extends Animal2{


public fish(String name,String color){
super(name,color);
}


public void run(){
System.out.println(name+"摇摇尾巴游啊游!");
}
}


class Demo3 {

public static void main(String[] args)
{

Dog d = new Dog("牧羊犬","棕色");
d.run();

/* //创建一个鱼对象
Fish f = new Fish("锦鲤","金黄色");
f.run();
*/


}
}
结果:

 

 

需求: 描述一个图形、圆形、 矩形三个类。不管哪种图形都会具备计算面积
与周长的行为,但是每种图形计算的方式不一致而已。

常量的命名规范:全部字母大写,单词与单词 之间 使用下划线分隔。


abstract不能与以下关键字共同修饰一个方法:
1. abstract不能与private共同修饰一个方法。
2. abstract 不能与static共同修饰一个方法。
3. abstract 不能与final共同修饰一个方法。

代码演示:

//abstract 抽象

//图形类
abstract class MyShape{

String name;

public MyShape(String name){
this.name = name;
}

public abstract void getArea();

public abstract void getLength();
}

//圆形 是属于图形类的一种
class Circle1 extends MyShape{

double r;

public static final double PI = 3.14;

public Circle1(String name,double r){
super(name);
this.r =r;
}

public void getArea(){
System.out.println(name+"的面积是:"+PI*r*r);
}

public void getLength(){
System.out.println(name+"的周长是:"+2*PI*r);
}
}

class Circle extends MyShape{

double r;

public static final double PI=3.14;

public Circle(String name,double r){
super(name);
this.r=r;
}
public void getArea(){
System.out.println(name+"的面积是:"+PI*r*r);
}
public void getLength(){
System.out.println(name+"的周长是:"+2*PI*r);
}
}

//矩形 属于图形中的 一种
class Rect extends MyShape{

int width;

int height;

public Rect(String name,int width, int height){
super(name);
this.width = width;
this.height = height;
}

public void getArea(){
System.out.println(name+"的面积是:"+width*height);
}

public void getLength(){
System.out.println(name+"的周长是:"+2*(width+height));
}
}

class Demo4
{
public static void main(String[] args)
{
//System.out.println("Hello World!");

Circle c = new Circle("圆形",4.0);
c.getArea();
c.getLength();

//矩形
Rect r = new Rect("矩形",3,4);
r.getArea();
r.getLength();

}
}
结果:

 

 


标签:name,void,public,关键字,static,抽象类,final,构造函数
来源: https://www.cnblogs.com/wj5626/p/15806009.html

专注分享技术,共同学习,共同进步。侵权联系[admin#icode9.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有